/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/versionedfile.py

  • Committer: Martin
  • Date: 2017-06-05 20:48:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6658.
  • Revision ID: gzlist@googlemail.com-20170605204831-20accykspjcrx0a8
Apply 2to3 dict fixer and clean up resulting mess using view helpers

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/versionedfile.py
44
44
from .registry import Registry
45
45
from .sixish import (
46
46
    BytesIO,
 
47
    viewitems,
 
48
    viewvalues,
47
49
    zip,
48
50
    )
49
51
from .textmerge import TextMerge
250
252
        refcounts = {}
251
253
        setdefault = refcounts.setdefault
252
254
        just_parents = set()
253
 
        for child_key, parent_keys in parent_map.iteritems():
 
255
        for child_key, parent_keys in viewitems(parent_map):
254
256
            if not parent_keys:
255
257
                # parent_keys may be None if a given VersionedFile claims to
256
258
                # not support graph operations.
491
493
            except KeyError:
492
494
                raise errors.RevisionNotPresent(version_id, self)
493
495
        # We need to filter out ghosts, because we can't diff against them.
494
 
        knit_versions = set(self.get_parent_map(knit_versions).keys())
 
496
        knit_versions = set(self.get_parent_map(knit_versions))
495
497
        lines = dict(zip(knit_versions,
496
498
            self._get_lf_split_line_list(knit_versions)))
497
499
        diffs = []
535
537
        for version, parent_ids, expected_sha1, mpdiff in records:
536
538
            needed_parents.update(p for p in parent_ids
537
539
                                  if not mpvf.has_version(p))
538
 
        present_parents = set(self.get_parent_map(needed_parents).keys())
 
540
        present_parents = set(self.get_parent_map(needed_parents))
539
541
        for parent_id, lines in zip(present_parents,
540
542
                self._get_lf_split_line_list(present_parents)):
541
543
            mpvf.add_version(lines, parent_id, [])
1095
1097
            this_parent_map = self.get_parent_map(pending)
1096
1098
            parent_map.update(this_parent_map)
1097
1099
            pending = set(itertools.chain.from_iterable(
1098
 
                this_parent_map.itervalues()))
 
1100
                viewvalues(this_parent_map)))
1099
1101
            pending.difference_update(parent_map)
1100
1102
        kg = _mod_graph.KnownGraph(parent_map)
1101
1103
        return kg
1297
1299
        """
1298
1300
        prefixes = self._partition_keys(keys)
1299
1301
        result = {}
1300
 
        for prefix, suffixes in prefixes.items():
 
1302
        for prefix, suffixes in viewitems(prefixes):
1301
1303
            path = self._mapper.map(prefix)
1302
1304
            vf = self._get_vf(path)
1303
1305
            parent_map = vf.get_parent_map(suffixes)
1304
 
            for key, parents in parent_map.items():
 
1306
            for key, parents in viewitems(parent_map):
1305
1307
                result[prefix + (key,)] = tuple(
1306
1308
                    prefix + (parent,) for parent in parents)
1307
1309
        return result
1353
1355
    def _iter_keys_vf(self, keys):
1354
1356
        prefixes = self._partition_keys(keys)
1355
1357
        sha1s = {}
1356
 
        for prefix, suffixes in prefixes.items():
 
1358
        for prefix, suffixes in viewitems(prefixes):
1357
1359
            path = self._mapper.map(prefix)
1358
1360
            vf = self._get_vf(path)
1359
1361
            yield prefix, suffixes, vf
1363
1365
        sha1s = {}
1364
1366
        for prefix,suffixes, vf in self._iter_keys_vf(keys):
1365
1367
            vf_sha1s = vf.get_sha1s(suffixes)
1366
 
            for suffix, sha1 in vf_sha1s.iteritems():
 
1368
            for suffix, sha1 in viewitems(vf_sha1s):
1367
1369
                sha1s[prefix + (suffix,)] = sha1
1368
1370
        return sha1s
1369
1371
 
1553
1555
        result.update(
1554
1556
            _mod_graph.StackedParentsProvider(
1555
1557
                self._providers).get_parent_map(keys))
1556
 
        for key, parents in result.iteritems():
 
1558
        for key, parents in viewitems(result):
1557
1559
            if parents == ():
1558
1560
                result[key] = (revision.NULL_REVISION,)
1559
1561
        return result
1732
1734
 
1733
1735
    def get_parent_map(self, keys):
1734
1736
        """See VersionedFiles.get_parent_map."""
1735
 
        return dict([((k,), tuple([(p,) for p in v]))
1736
 
            for k,v in self._get_parent_map([k for (k,) in keys]).iteritems()])
 
1737
        parent_view = viewitems(self._get_parent_map(k for (k,) in keys))
 
1738
        return dict(((k,), tuple((p,) for p in v)) for k, v in parent_view)
1737
1739
 
1738
1740
    def get_sha1s(self, keys):
1739
1741
        """See VersionedFiles.get_sha1s."""
1889
1891
    # gc-optimal ordering is approximately reverse topological,
1890
1892
    # properly grouped by file-id.
1891
1893
    per_prefix_map = {}
1892
 
    for item in parent_map.iteritems():
 
1894
    for item in viewitems(parent_map):
1893
1895
        key = item[0]
1894
1896
        if isinstance(key, str) or len(key) == 1:
1895
1897
            prefix = ''
1936
1938
 
1937
1939
    def get_new_keys(self):
1938
1940
        return self.new_keys
1939
 
    
 
1941
 
1940
1942
    def get_unsatisfied_refs(self):
1941
 
        return self.refs.iterkeys()
 
1943
        return self.refs.keys()
1942
1944
 
1943
1945
    def _satisfy_refs_for_key(self, key):
1944
1946
        try:
1958
1960
            self._satisfy_refs_for_key(key)
1959
1961
 
1960
1962
    def get_referrers(self):
1961
 
        result = set()
1962
 
        for referrers in self.refs.itervalues():
1963
 
            result.update(referrers)
1964
 
        return result
 
1963
        return set(itertools.chain.from_iterable(viewvalues(self.refs)))
1965
1964
 
1966
1965
 
1967
1966