« back to all changes in this revision
Viewing changes to bzrlib/weave.py
- browse files at revision 1442.1.48
- compare with another revision
- download diff
- download tarball
- view history from revision 1442.1.48
- Committer: Robert Collins
- Date: 2005-10-16 23:53:02 UTC
- mto: This revision was merged to the branch mainline in revision 1459.
- Revision ID: robertc@lifelesslap.robertcollins.net-20051016235302-818de607403e1c6e
test that the presence of a signature does not make a missing base file magically appear present
- files added:
- HACKING
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- contrib/emacs
- files removed:
- bzrlib/meta_store.py
- plugins/changeset
- files renamed:
- plugins/ => bzrlib/plugins/
- tools/testweave.py => bzrlib/selftest/test_weave.py
- bzrlib/store.py => bzrlib/store/__init__.py
- effbot/ => bzrlib/util/effbot/
- elementtree/ => bzrlib/util/elementtree/
- urlgrabber/ => bzrlib/util/urlgrabber/
- bzrlib/newinventory.py => contrib/newinventory.py
- files modified:
- .bzrignore
- bzr *
added
removed
bzrlib/weave.py
21
21
22
22
"""Weave - storage of related text file versions"""
23
23
24
# before intset (r923) 2000 versions in 41.5s
25
# with intset (r926) 2000 versions in 93s !!!
26
# better to just use plain sets.
27
28
# making _extract build and return a list, rather than being a generator
29
# takes 37.94s
30
31
# with python -O, r923 does 2000 versions in 36.87s
32
33
# with optimizations to avoid mutating lists - 35.75! I guess copying
34
# all the elements every time costs more than the small manipulations.
35
# a surprisingly small change.
36
37
# r931, which avoids using a generator for extract, does 36.98s
38
39
# with memoized inclusions, takes 41.49s; not very good
40
41
# with slots, takes 37.35s; without takes 39.16, a bit surprising
42
43
# with the delta calculation mixed in with the add method, rather than
44
# separated, takes 36.78s
45
46
# with delta folded in and mutation of the list, 36.13s
47
48
# with all this and simplification of add code, 33s
49
50
51
# TODO: Perhaps have copy method for Weave instances?
52
24
53
25
# XXX: If we do weaves this way, will a merge still behave the same
54
26
# way if it's done in a different order? That's a pretty desirable
59
31
# binaries, perhaps by naively splitting on \n or perhaps using
60
32
# something like a rolling checksum.
61
33
62
# TODO: Track version names as well as indexes.
63
64
34
# TODO: End marker for each version so we can stop reading?
65
35
66
36
# TODO: Check that no insertion occurs inside a deletion that was
73
43
74
44
# TODO: Parallel-extract that passes back each line along with a
75
45
# description of which revisions include it. Nice for checking all
76
# shas in parallel.
77
78
46
# shas or calculating stats in parallel.
47
48
# TODO: Using a single _extract routine and then processing the output
49
# is probably inefficient. It's simple enough that we can afford to
50
# have slight specializations for different ways its used: annotate,
51
# basis for add, get, etc.
52
53
# TODO: Probably the API should work only in names to hide the integer
54
# indexes from the user.
55
56
# TODO: Is there any potential performance win by having an add()
57
# variant that is passed a pre-cooked version of the single basis
58
# version?
59
60
# TODO: Reweave can possibly be made faster by remembering diffs
61
# where the basis and destination are unchanged.
62
63
# FIXME: Sometimes we will be given a parents list for a revision
64
# that includes some redundant parents (i.e. already a parent of
65
# something in the list.) We should eliminate them. This can
66
# be done fairly efficiently because the sequence numbers constrain
67
# the possible relationships.
68
69
70
import sha
71
from difflib import SequenceMatcher
72
73
from bzrlib.trace import mutter
79
74
80
75
81
76
class WeaveError(Exception):
84
79
85
80
class WeaveFormatError(WeaveError):
86
81
"""Weave invariant violated"""
82
83
84
class WeaveParentMismatch(WeaveError):
85
"""Parents are mismatched between two revisions."""
87
86
88
87
89
88
class Weave(object):
118
117
The instruction can be '{' or '}' for an insertion block, and '['
119
118
and ']' for a deletion block respectively. The version is the
120
119
integer version index. There is no replace operator, only deletes
121
and inserts.
120
and inserts. For '}', the end of an insertion, there is no
121
version parameter because it always closes the most recently
122
opened insertion.
122
123
123
124
Constraints/notes:
124
125
160
161
each version; the parent's parents are implied.
161
162
162
163
_sha1s
163
List of hex SHA-1 of each version, or None if not recorded.
164
List of hex SHA-1 of each version.
165
166
_names
167
List of symbolic names for each version. Each should be unique.
168
169
_name_map
170
For each name, the version number.
171
172
_weave_name
173
Descriptive name of this weave; typically the filename if known.
174
Set by read_weave.
164
175
"""
165
176
166
__slots__ = ['_weave', '_parents', '_sha1s']
177
__slots__ = ['_weave', '_parents', '_sha1s', '_names', '_name_map',
178
'_weave_name']
167
179
168
def __init__(self):
180
def __init__(self, weave_name=None):
169
181
self._weave = []
170
182
self._parents = []
171
183
self._sha1s = []
172
184
self._names = []
185
self._name_map = {}
186
self._weave_name = weave_name
187
188
189
def copy(self):
190
"""Return a deep copy of self.
191
192
The copy can be modified without affecting the original weave."""
193
other = Weave()
194
other._weave = self._weave[:]
195
other._parents = self._parents[:]
196
other._sha1s = self._sha1s[:]
197
other._names = self._names[:]
198
other._name_map = self._name_map.copy()
199
other._weave_name = self._weave_name
200
return other
173
201
174
202
def __eq__(self, other):
175
203
if not isinstance(other, Weave):
176
204
return False
177
205
return self._parents == other._parents \
178
and self._weave == other._weave
206
and self._weave == other._weave \
207
and self._sha1s == other._sha1s
208
179
209
180
181
210
def __ne__(self, other):
182
211
return not self.__eq__(other)
183
212
184
185
def add(self, parents, text):
213
214
def maybe_lookup(self, name_or_index):
215
"""Convert possible symbolic name to index, or pass through indexes."""
216
if isinstance(name_or_index, (int, long)):
217
return name_or_index
218
else:
219
return self.lookup(name_or_index)
220
221
222
def lookup(self, name):
223
"""Convert symbolic version name to index."""
224
try:
225
return self._name_map[name]
226
except KeyError:
227
raise WeaveError("name %r not present in weave %r" %
228
(name, self._weave_name))
229
230
231
def iter_names(self):
232
"""Yield a list of all names in this weave."""
233
return iter(self._names)
234
235
def idx_to_name(self, version):
236
return self._names[version]
237
238
239
def _check_repeated_add(self, name, parents, text, sha1):
240
"""Check that a duplicated add is OK.
241
242
If it is, return the (old) index; otherwise raise an exception.
243
"""
244
idx = self.lookup(name)
245
if sorted(self._parents[idx]) != sorted(parents):
246
raise WeaveError("name \"%s\" already present in weave "
247
"with different parents" % name)
248
if sha1 != self._sha1s[idx]:
249
raise WeaveError("name \"%s\" already present in weave "
250
"with different text" % name)
251
return idx
252
253
254
255
def add(self, name, parents, text, sha1=None):
186
256
"""Add a single text on top of the weave.
187
257
188
258
Returns the index number of the newly added version.
189
259
260
name
261
Symbolic name for this version.
262
(Typically the revision-id of the revision that added it.)
263
190
264
parents
191
265
List or set of direct parent version numbers.
192
266
193
267
text
194
Sequence of lines to be added in the new version."""
195
268
Sequence of lines to be added in the new version.
269
270
sha -- SHA-1 of the file, if known. This is trusted to be
271
correct if supplied.
272
"""
273
from bzrlib.osutils import sha_strings
274
275
assert isinstance(name, basestring)
276
if sha1 is None:
277
sha1 = sha_strings(text)
278
if name in self._name_map:
279
return self._check_repeated_add(name, parents, text, sha1)
280
281
parents = map(self.maybe_lookup, parents)
196
282
self._check_versions(parents)
197
283
## self._check_lines(text)
198
284
new_version = len(self._parents)
199
285
200
import sha
201
s = sha.new()
202
map(s.update, text)
203
sha1 = s.hexdigest()
204
del s
205
286
206
# if we abort after here the weave will be corrupt
207
self._parents.append(frozenset(parents))
287
# if we abort after here the (in-memory) weave will be corrupt because only
288
# some fields are updated
289
self._parents.append(parents[:])
208
290
self._sha1s.append(sha1)
291
self._names.append(name)
292
self._name_map[name] = new_version
209
293
210
294
211
295
if not parents:
216
300
if text:
217
301
self._weave.append(('{', new_version))
218
302
self._weave.extend(text)
219
self._weave.append(('}', new_version))
303
self._weave.append(('}', None))
220
304
221
305
return new_version
222
306
238
322
basis_lineno.append(lineno)
239
323
basis_lines.append(line)
240
324
241
# another small special case: a merge, producing the same text as auto-merge
325
# another small special case: a merge, producing the same text
326
# as auto-merge
242
327
if text == basis_lines:
243
328
return new_version
244
329
252
337
#print 'basis_lines:', basis_lines
253
338
#print 'new_lines: ', lines
254
339
255
from difflib import SequenceMatcher
256
340
s = SequenceMatcher(None, basis_lines, text)
257
341
258
342
# offset gives the number of lines that have been inserted
287
371
# we don't destroy ourselves
288
372
i = i2 + offset
289
373
self._weave[i:i] = ([('{', new_version)]
290
+ text[j1:j2]
291
+ [('}', new_version)])
374
+ text[j1:j2]
375
+ [('}', None)])
292
376
offset += 2 + (j2 - j1)
293
377
294
378
return new_version
295
379
380
def add_identical(self, old_rev_id, new_rev_id, parents):
381
"""Add an identical text to old_rev_id as new_rev_id."""
382
old_lines = self.get(self.lookup(old_rev_id))
383
self.add(new_rev_id, parents, old_lines)
296
384
297
385
def inclusions(self, versions):
298
386
"""Return set of all ancestors of given version(s)."""
299
387
i = set(versions)
300
v = max(versions)
301
try:
302
while v >= 0:
303
if v in i:
304
# include all its parents
305
i.update(self._parents[v])
306
v -= 1
307
return i
308
except IndexError:
309
raise ValueError("version %d not present in weave" % v)
388
for v in xrange(max(versions), 0, -1):
389
if v in i:
390
# include all its parents
391
i.update(self._parents[v])
392
return i
393
## except IndexError:
394
## raise ValueError("version %d not present in weave" % v)
395
396
397
def parents(self, version):
398
return self._parents[version]
399
400
401
def parent_names(self, version):
402
"""Return version names for parents of a version."""
403
return map(self.idx_to_name, self._parents[self.lookup(version)])
310
404
311
405
312
406
def minimal_parents(self, version):
352
446
raise IndexError("invalid version number %r" % i)
353
447
354
448
355
def annotate(self, index):
356
return list(self.annotate_iter(index))
357
358
359
def annotate_iter(self, version):
449
def annotate(self, name_or_index):
450
return list(self.annotate_iter(name_or_index))
451
452
453
def annotate_iter(self, name_or_index):
360
454
"""Yield list of (index-id, line) pairs for the specified version.
361
455
362
456
The index indicates when the line originated in the weave."""
363
for origin, lineno, text in self._extract([version]):
457
incls = [self.maybe_lookup(name_or_index)]
458
for origin, lineno, text in self._extract(incls):
364
459
yield origin, text
365
460
366
461
384
479
if c == '{':
385
480
istack.append(v)
386
481
elif c == '}':
387
oldv = istack.pop()
482
istack.pop()
388
483
elif c == '[':
389
484
assert v not in dset
390
485
dset.add(v)
410
505
411
506
The set typically but not necessarily corresponds to a version.
412
507
"""
508
for i in versions:
509
if not isinstance(i, int):
510
raise ValueError(i)
511
413
512
included = self.inclusions(versions)
414
513
415
514
istack = []
431
530
assert v not in istack
432
531
istack.append(v)
433
532
elif c == '}':
434
oldv = istack.pop()
435
assert oldv == v
533
istack.pop()
436
534
elif c == '[':
437
535
if v in included:
438
536
assert v not in dset
461
559
462
560
463
561
464
def get_iter(self, version):
562
def get_iter(self, name_or_index):
465
563
"""Yield lines for the specified version."""
466
for origin, lineno, line in self._extract([version]):
564
incls = [self.maybe_lookup(name_or_index)]
565
for origin, lineno, line in self._extract(incls):
467
566
yield line
468
567
469
568
470
def get(self, index):
471
return list(self.get_iter(index))
569
def get_text(self, name_or_index):
570
return ''.join(self.get_iter(name_or_index))
571
assert isinstance(version, int)
572
573
574
def get_lines(self, name_or_index):
575
return list(self.get_iter(name_or_index))
576
577
578
get = get_lines
472
579
473
580
474
581
def mash_iter(self, included):
475
582
"""Return composed version of multiple included versions."""
583
included = map(self.maybe_lookup, included)
476
584
for origin, lineno, text in self._extract(included):
477
585
yield text
478
586
508
616
509
617
# try extracting all versions; this is a bit slow and parallel
510
618
# extraction could be used
511
import sha
512
619
nv = self.numversions()
513
620
for version in range(nv):
514
621
if progress_bar:
539
646
If there is a chunk of the file where there's no diagreement,
540
647
only one alternative is given.
541
648
"""
542
543
649
# approach: find the included versions common to all the
544
650
# merged versions
545
651
raise NotImplementedError()
565
671
If line1=line2, this is a pure insert; if newlines=[] this is a
566
672
pure delete. (Similar to difflib.)
567
673
"""
568
674
raise NotImplementedError()
569
675
570
676
571
677
def plan_merge(self, ver_a, ver_b):
665
771
state
666
772
667
773
668
669
670
671
672
673
def weave_info(w):
674
"""Show some text information about the weave."""
675
print '%6s %40s %20s' % ('ver', 'sha1', 'parents')
676
for i in (6, 40, 20):
774
def join(self, other):
775
"""Integrate versions from other into this weave.
776
777
The resulting weave contains all the history of both weaves;
778
any version you could retrieve from either self or other can be
779
retrieved from self after this call.
780
781
It is illegal for the two weaves to contain different values
782
or different parents for any version. See also reweave().
783
"""
784
if other.numversions() == 0:
785
return # nothing to update, easy
786
# two loops so that we do not change ourselves before verifying it
787
# will be ok
788
# work through in index order to make sure we get all dependencies
789
for other_idx, name in enumerate(other._names):
790
if self._check_version_consistent(other, other_idx, name):
791
continue
792
for other_idx, name in enumerate(other._names):
793
# TODO: If all the parents of the other version are already
794
# present then we can avoid some work by just taking the delta
795
# and adjusting the offsets.
796
new_parents = self._imported_parents(other, other_idx)
797
lines = other.get_lines(other_idx)
798
sha1 = other._sha1s[other_idx]
799
self.add(name, new_parents, lines, sha1)
800
801
802
def _imported_parents(self, other, other_idx):
803
"""Return list of parents in self corresponding to indexes in other."""
804
new_parents = []
805
for parent_idx in other._parents[other_idx]:
806
parent_name = other._names[parent_idx]
807
if parent_name not in self._names:
808
# should not be possible
809
raise WeaveError("missing parent {%s} of {%s} in %r"
810
% (parent_name, other._name_map[other_idx], self))
811
new_parents.append(self._name_map[parent_name])
812
return new_parents
813
814
def _check_version_consistent(self, other, other_idx, name):
815
"""Check if a version in consistent in this and other.
816
817
To be consistent it must have:
818
819
* the same text
820
* the same direct parents (by name, not index, and disregarding
821
order)
822
823
If present & correct return True;
824
if not present in self return False;
825
if inconsistent raise error."""
826
this_idx = self._name_map.get(name, -1)
827
if this_idx != -1:
828
if self._sha1s[this_idx] != other._sha1s[other_idx]:
829
raise WeaveError("inconsistent texts for version {%s} "
830
"when joining weaves"
831
% (name))
832
self_parents = self._parents[this_idx]
833
other_parents = other._parents[other_idx]
834
n1 = [self._names[i] for i in self_parents]
835
n2 = [other._names[i] for i in other_parents]
836
n1.sort()
837
n2.sort()
838
if n1 != n2:
839
raise WeaveParentMismatch("inconsistent parents "
840
"for version {%s}: %s vs %s" % (name, n1, n2))
841
else:
842
return True # ok!
843
else:
844
return False
845
846
def reweave(self, other):
847
"""Reweave self with other."""
848
new_weave = reweave(self, other)
849
for attr in self.__slots__:
850
setattr(self, attr, getattr(new_weave, attr))
851
852
853
def reweave(wa, wb):
854
"""Combine two weaves and return the result.
855
856
This works even if a revision R has different parents in
857
wa and wb. In the resulting weave all the parents are given.
858
859
This is done by just building up a new weave, maintaining ordering
860
of the versions in the two inputs. More efficient approaches
861
might be possible but it should only be necessary to do
862
this operation rarely, when a new previously ghost version is
863
inserted.
864
"""
865
wr = Weave()
866
ia = ib = 0
867
queue_a = range(wa.numversions())
868
queue_b = range(wb.numversions())
869
# first determine combined parents of all versions
870
# map from version name -> all parent names
871
combined_parents = _reweave_parent_graphs(wa, wb)
872
mutter("combined parents: %r", combined_parents)
873
order = _make_reweave_order(wa._names, wb._names, combined_parents)
874
mutter("order to reweave: %r", order)
875
for name in order:
876
if name in wa._name_map:
877
lines = wa.get_lines(name)
878
if name in wb._name_map:
879
assert lines == wb.get_lines(name)
880
else:
881
lines = wb.get_lines(name)
882
wr.add(name, combined_parents[name], lines)
883
return wr
884
885
886
def _reweave_parent_graphs(wa, wb):
887
"""Return combined parent ancestry for two weaves.
888
889
Returned as a list of (version_name, set(parent_names))"""
890
combined = {}
891
for weave in [wa, wb]:
892
for idx, name in enumerate(weave._names):
893
p = combined.setdefault(name, set())
894
p.update(map(weave.idx_to_name, weave._parents[idx]))
895
return combined
896
897
898
def _make_reweave_order(wa_order, wb_order, combined_parents):
899
"""Return an order to reweave versions respecting parents."""
900
done = set()
901
result = []
902
ia = ib = 0
903
next_a = next_b = None
904
len_a = len(wa_order)
905
len_b = len(wb_order)
906
while ia < len(wa_order) or ib < len(wb_order):
907
if ia < len_a:
908
next_a = wa_order[ia]
909
if next_a in done:
910
ia += 1
911
continue
912
if combined_parents[next_a].issubset(done):
913
ia += 1
914
result.append(next_a)
915
done.add(next_a)
916
continue
917
if ib < len_b:
918
next_b = wb_order[ib]
919
if next_b in done:
920
ib += 1
921
continue
922
elif combined_parents[next_b].issubset(done):
923
ib += 1
924
result.append(next_b)
925
done.add(next_b)
926
continue
927
raise WeaveError("don't know how to reweave at {%s} and {%s}"
928
% (next_a, next_b))
929
return result
930
931
932
def weave_toc(w):
933
"""Show the weave's table-of-contents"""
934
print '%6s %50s %10s %10s' % ('ver', 'name', 'sha1', 'parents')
935
for i in (6, 50, 10, 10):
677
936
print '-' * i,
678
937
print
679
938
for i in range(w.numversions()):
680
939
sha1 = w._sha1s[i]
681
print '%6d %40s %s' % (i, sha1, ' '.join(map(str, w._parents[i])))
682
683
684
685
def weave_stats(weave_file):
686
from bzrlib.progress import ProgressBar
940
name = w._names[i]
941
parent_str = ' '.join(map(str, w._parents[i]))
942
print '%6d %-50.50s %10.10s %s' % (i, name, sha1, parent_str)
943
944
945
946
def weave_stats(weave_file, pb):
687
947
from bzrlib.weavefile import read_weave
688
948
689
pb = ProgressBar()
690
691
949
wf = file(weave_file, 'rb')
692
950
w = read_weave(wf)
693
951
# FIXME: doesn't work on pipes
697
955
vers = len(w)
698
956
for i in range(vers):
699
957
pb.update('checking sizes', i, vers)
700
for line in w.get_iter(i):
958
for origin, lineno, line in w._extract([i]):
701
959
total += len(line)
702
960
703
961
pb.clear()
706
964
print 'weave file %9d bytes' % weave_size
707
965
print 'total contents %9d bytes' % total
708
966
print 'compression ratio %9.2fx' % (float(total) / float(weave_size))
709
967
if vers:
968
avg = total/vers
969
print 'average size %9d bytes' % avg
970
print 'relative size %9.2fx' % (float(weave_size) / float(avg))
710
971
711
972
712
973
def usage():
721
982
Write out specified version.
722
983
weave check WEAVEFILE
723
984
Check consistency of all versions.
724
weave info WEAVEFILE
985
weave toc WEAVEFILE
725
986
Display table of contents.
726
weave add WEAVEFILE [BASE...] < NEWTEXT
987
weave add WEAVEFILE NAME [BASE...] < NEWTEXT
727
988
Add NEWTEXT, with specified parent versions.
728
989
weave annotate WEAVEFILE VERSION
729
990
Display origin of each line.
731
992
Display composite of all selected versions.
732
993
weave merge WEAVEFILE VERSION1 VERSION2 > OUT
733
994
Auto-merge two versions and display conflicts.
995
weave diff WEAVEFILE VERSION1 VERSION2
996
Show differences between two versions.
734
997
735
998
example:
736
999
737
1000
% weave init foo.weave
738
1001
% vi foo.txt
739
% weave add foo.weave < foo.txt
1002
% weave add foo.weave ver0 < foo.txt
740
1003
added version 0
741
1004
742
1005
(create updated version)
743
1006
% vi foo.txt
744
1007
% weave get foo.weave 0 | diff -u - foo.txt
745
% weave add foo.weave 0 < foo.txt
1008
% weave add foo.weave ver1 0 < foo.txt
746
1009
added version 1
747
1010
748
1011
% weave get foo.weave 0 > foo.txt (create forked version)
749
1012
% vi foo.txt
750
% weave add foo.weave 0 < foo.txt
1013
% weave add foo.weave ver2 0 < foo.txt
751
1014
added version 2
752
1015
753
1016
% weave merge foo.weave 1 2 > foo.txt (merge them)
754
1017
% vi foo.txt (resolve conflicts)
755
% weave add foo.weave 1 2 < foo.txt (commit merged version)
1018
% weave add foo.weave merged 1 2 < foo.txt (commit merged version)
756
1019
757
1020
"""
758
1021
761
1024
def main(argv):
762
1025
import sys
763
1026
import os
764
from weavefile import write_weave, read_weave
1027
try:
1028
import bzrlib
1029
except ImportError:
1030
# in case we're run directly from the subdirectory
1031
sys.path.append('..')
1032
import bzrlib
1033
from bzrlib.weavefile import write_weave, read_weave
765
1034
from bzrlib.progress import ProgressBar
766
1035
767
#import psyco
768
#psyco.full()
1036
try:
1037
import psyco
1038
psyco.full()
1039
except ImportError:
1040
pass
1041
1042
if len(argv) < 2:
1043
usage()
1044
return 0
769
1045
770
1046
cmd = argv[1]
771
1047
777
1053
elif cmd == 'add':
778
1054
w = readit()
779
1055
# at the moment, based on everything in the file
780
parents = map(int, argv[3:])
1056
name = argv[3]
1057
parents = map(int, argv[4:])
781
1058
lines = sys.stdin.readlines()
782
ver = w.add(parents, lines)
1059
ver = w.add(name, parents, lines)
783
1060
write_weave(w, file(argv[2], 'wb'))
784
print 'added version %d' % ver
1061
print 'added version %r %d' % (name, ver)
785
1062
elif cmd == 'init':
786
1063
fn = argv[2]
787
1064
if os.path.exists(fn):
796
1073
w = readit()
797
1074
sys.stdout.writelines(w.mash_iter(map(int, argv[3:])))
798
1075
1076
elif cmd == 'diff':
1077
from difflib import unified_diff
1078
w = readit()
1079
fn = argv[2]
1080
v1, v2 = map(int, argv[3:5])
1081
lines1 = w.get(v1)
1082
lines2 = w.get(v2)
1083
diff_gen = unified_diff(lines1, lines2,
1084
'%s version %d' % (fn, v1),
1085
'%s version %d' % (fn, v2))
1086
sys.stdout.writelines(diff_gen)
1087
799
1088
elif cmd == 'annotate':
800
1089
w = readit()
801
1090
# newline is added to all lines regardless; too hard to get
809
1098
print '%5d | %s' % (origin, text)
810
1099
lasto = origin
811
1100
812
elif cmd == 'info':
813
weave_info(readit())
1101
elif cmd == 'toc':
1102
weave_toc(readit())
814
1103
815
1104
elif cmd == 'stats':
816
weave_stats(argv[2])
1105
weave_stats(argv[2], ProgressBar())
817
1106
818
1107
elif cmd == 'check':
819
1108
w = readit()
865
1154
raise ValueError('unknown command %r' % cmd)
866
1155
867
1156
1157
1158
def profile_main(argv):
1159
import tempfile, hotshot, hotshot.stats
1160
1161
prof_f = tempfile.NamedTemporaryFile()
1162
1163
prof = hotshot.Profile(prof_f.name)
1164
1165
ret = prof.runcall(main, argv)
1166
prof.close()
1167
1168
stats = hotshot.stats.load(prof_f.name)
1169
#stats.strip_dirs()
1170
stats.sort_stats('cumulative')
1171
## XXX: Might like to write to stderr or the trace file instead but
1172
## print_stats seems hardcoded to stdout
1173
stats.print_stats(20)
1174
1175
return ret
1176
1177
868
1178
if __name__ == '__main__':
869
1179
import sys
870
sys.exit(main(sys.argv))
1180
if '--profile' in sys.argv:
1181
args = sys.argv[:]
1182
args.remove('--profile')
1183
sys.exit(profile_main(args))
1184
else:
1185
sys.exit(main(sys.argv))
1186
Loggerhead is a web-based interface for Breezy
Version: 2.0.1