-=[ Mr. Bumblebee ]=-
_Indonesia_
ó
¦îNc @@ sˆ d d l m Z d d l Z d d l m Z m Z m Z m Z m Z d Z d e
f d „ ƒ YZ d e
f d „ ƒ YZ d e
f d
„ ƒ YZ
d e
f d „ ƒ YZ d
e
f d „ ƒ YZ d e
f d „ ƒ YZ d e
f d „ ƒ YZ d e
f d „ ƒ YZ d „ Z d „ Z d e
f d „ ƒ YZ d d d d d d d g Z y d d l m Z Wn0 e k
rƒZ e j e ƒ d d l m Z n Xd S( i ( t absolute_importN( t debugt errorst osutilst revisiont tracei t DictParentsProviderc B@ s) e Z d Z d „ Z d „ Z d „ Z RS( s% A parents provider for Graph objects.c C@ s
| | _ d S( N( t ancestry( t selfR ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt __init__9 s c C@ s d | j S( Ns DictParentsProvider(%r)( R ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt __repr__< s c C@ s< | j } t g | D]" } | | k r | | | f ^ q ƒ S( s) See StackedParentsProvider.get_parent_map( R t dict( R t keysR t k( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt get_parent_mapD s ( t __name__t
__module__t __doc__R R
R ( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR 6 s t StackedParentsProviderc B@ s) e Z d Z d „ Z d „ Z d „ Z RS( s’ A parents provider which stacks (or unions) multiple providers.
The providers are queries in the order of the provided parent_providers.
c C@ s
| | _ d S( N( t _parent_providers( R t parent_providers( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR P s c C@ s d | j j | j f S( Ns %s(%r)( t __class__R R ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR
S s c C@ sÏ i } t | ƒ } xe | j D]Z } t | d d ƒ } | d k rF q n | | ƒ } | j | ƒ | j | ƒ | s Pq q W| s„ | SxD | j D]9 } | j | ƒ } | j | ƒ | j | ƒ | sŽ PqŽ qŽ W| S( så Get a mapping of keys => parents
A dictionary is returned with an entry for each key present in this
source. If this source doesn't have information about a key, it should
not include an entry.
[NULL_REVISION] is used as the parent of the first user-committed
revision. Its parent list is empty.
:param keys: An iterable returning keys to check (eg revision_ids)
:return: A dictionary mapping each key to its parents
t get_cached_parent_mapN( t setR t getattrt Nonet updatet difference_updateR ( R R t foundt remainingt parents_providert
get_cachedt new_found( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR V s*
( R R R R R
R ( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR J s t CachingParentsProviderc B@ s_ e Z d Z d d d „ Z d „ Z e d „ Z d „ Z d „ Z d „ Z
d „ Z d „ Z RS(
s– A parents provider which will cache the revision => parents as a dict.
This is useful for providers which have an expensive look up.
Either a ParentsProvider or a get_parent_map-like callback may be
supplied. If it provides extra un-asked-for parents, they will be cached,
but filtered out of get_parent_map.
The cache is enabled by default, but may be disabled and re-enabled.
c C@ sJ | | _ | d k r' | j j | _ n | | _ d | _ | j t ƒ d S( sý Constructor.
:param parent_provider: The ParentProvider to use. It or
get_parent_map must be supplied.
:param get_parent_map: The get_parent_map callback to use. It or
parent_provider must be supplied.
N( t _real_providerR R t _get_parent_mapt _cachet enable_cachet True( R t parent_providerR ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR ‰ s c C@ s d | j j | j f S( Ns %s(%r)( R R R" ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR
™ s c C@ s@ | j d k r t d ƒ ‚ n i | _ | | _ t ƒ | _ d S( s
Enable cache.s# Cache enabled when already enabled.N( R$ R t AssertionErrort
_cache_missesR t missing_keys( R t cache_misses( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR% œ s
c C@ s" d | _ d | _ t ƒ | _ d S( s Disable and clear the cache.N( R R$ R) R R* ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt
disable_cache¤ s c C@ s | j d k r d St | j ƒ S( s( Return any cached get_parent_map values.N( R$ R R ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt get_cached_mapª s c C@ sL | j } | d k r i St g | D]" } | | k r# | | | f ^ q# ƒ S( s¿ Return items from the cache.
This returns the same info as get_parent_map, but explicitly does not
invoke the supplied ParentsProvider to search for uncached values.
N( R$ R R ( R R t cachet key( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR ° s c @ sô | j ‰ ˆ d k r' | j | ƒ ‰ nŠ t ‡ f d † | Dƒ ƒ } | j | j ƒ | r± | j | ƒ } ˆ j | ƒ | j r± x- | D]" } | | k r… | j | ƒ q… q… Wq± n i } x6 | D]. } ˆ j | ƒ } | d k r¾ | | | <q¾ q¾ W| S( s* See StackedParentsProvider.get_parent_map.c 3@ s! | ] } | ˆ k r | Vq d S( N( ( t .0R/ ( R. ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pys <genexpr>Á s N(
R$ R R# R R R* R R) t note_missing_keyt get( R R t needed_revisionst
parent_mapR/ t resultt value( ( R. s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR » s$
c C@ s | j r | j j | ƒ n d S( s Note that key is a missing key.N( R) R* t add( R R/ ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR1 Ò s N(
R R R R R R
R& R% R, R- R R R1 ( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR! ~ s
t CallableToParentsProviderAdapterc B@ s) e Z d Z d „ Z d „ Z d „ Z RS( s¼ A parents provider that adapts any callable to the parents provider API.
i.e. it accepts calls to self.get_parent_map and relays them to the
callable it was constructed with.
c C@ s
| | _ d S( N( t callable( R t
a_callable( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR ß s c C@ s d | j j | j f S( Ns %s(%r)( R R R9 ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR
â s c C@ s
| j | ƒ S( N( R9 ( R R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR å s ( R R R R R
R ( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR8 Ø s t Graphc B@ s" e Z d Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z
d „ Z d
„ Z d „ Z
d „ Z d
„ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z e d „ Z d „ Z d d „ Z d „ Z d „ Z d „ Z d „ Z! d „ Z" RS( s Provide incremental access to revision graphs.
This is the generic implementation; it is intended to be subclassed to
specialize it for other repository types.
c C@ s[ t | d d ƒ d k r' | j | _ n t | d d ƒ d k rN | j | _ n | | _ d S( sŸ Construct a Graph that uses several graphs as its input
This should not normally be invoked directly, because there may be
specialized implementations for particular repository types. See
Repository.get_graph().
:param parents_provider: An object providing a get_parent_map call
conforming to the behavior of
StackedParentsProvider.get_parent_map.
t get_parentsR N( R R R< R t _parents_provider( R R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR ð s
c C@ s d | j S( Ns Graph(%r)( R= ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR
s c G@ s% | j | ƒ \ } } } | j | ƒ S( sÌ Determine the lowest common ancestors of the provided revisions
A lowest common ancestor is a common ancestor none of whose
descendants are common ancestors. In graphs, unlike trees, there may
be multiple lowest common ancestors.
This algorithm has two phases. Phase 1 identifies border ancestors,
and phase 2 filters border ancestors to determine lowest common
ancestors.
In phase 1, border ancestors are identified, using a breadth-first
search starting at the bottom of the graph. Searches are stopped
whenever a node or one of its descendants is determined to be common
In phase 2, the border ancestors are filtered to find the least
common ancestors. This is done by searching the ancestries of each
border ancestor.
Phase 2 is perfomed on the principle that a border ancestor that is
not an ancestor of any other border ancestor is a least common
ancestor.
Searches are stopped when they find a node that is determined to be a
common ancestor of all border ancestors, because this shows that it
cannot be a descendant of any border ancestor.
The scaling of this operation should be proportional to:
1. The number of uncommon ancestors
2. The number of border ancestors
3. The length of the shortest path between a border ancestor and an
ancestor of all border ancestors.
( t _find_border_ancestorst heads( R t revisionst
border_commont commont sides( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt find_lca s "c C@ sd | j | | g ƒ \ } } } | j | | ƒ | d j } | d j } | j | ƒ | j | ƒ f S( s4 Determine the graph difference between two revisionsi i ( R> t _search_for_extra_commont seent
difference( R t
left_revisiont right_revisiont borderRB t searcherst leftt right( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt find_difference, s
c C@ sP | j | j | | ƒ ƒ } t t | ƒ ƒ } | j | g ƒ } t | ƒ | j S( s: Find descendants of old_key that are ancestors of new_key.( t
get_child_mapt _find_descendant_ancestorsR; R t _make_breadth_first_searchert listRF ( R t old_keyt new_keyt child_mapt grapht searcher( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt find_descendants5 s
c C@ s‰ | j | g ƒ } | j | g ƒ } xO | D]G } | j j | ƒ } | j | ƒ | j | j ƒ ƒ } | j | ƒ q+ W| j j | j ƒ S( s= Find ancestors of new_key that may be descendants of old_key.( RQ RF t intersectiont stop_searching_anyt find_seen_ancestorst stepRG ( R RS RT t stopt descendantsR@ t old_stopt seen_stop( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRP > s
c C@ si | j j | ƒ } i } xJ t | j ƒ ƒ D]6 \ } } x' | D] } | j | g ƒ j | ƒ q> Wq+ W| S( sï Get a mapping from parents to children of the specified keys.
This is simply the inversion of get_parent_map. Only supplied keys
will be discovered as children.
:return: a dict of key:child_list for keys.
( R= R t sortedt itemst
setdefaultt append( R R R4 t parent_childt childt parentst parent( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRO I s
!c C@ sl t | ƒ } | } d } t j } d | | <t | j ƒ ƒ } i } x| | k r_| | | <| d 7} t | g ƒ } | j | ƒ | j | ƒ }
|
j | d ƒ } | s¾ t
j | | ƒ ‚ n | d } g } x… | D]} }
|
j |
d ƒ } | sù qÕ n | d } | |
d } | | k r)| | | S| | k r;qÕ n | | | <| j | ƒ qÕ W| } qF W| | | S( s“ Find the left-hand distance to the NULL_REVISION.
(This can also be considered the revno of a branch at
target_revision_id.)
:param target_revision_id: A revision_id which we would like to know
the revno for.
:param known_revision_ids: [(revision_id, revno)] A list of known
revno, revision_id tuples. We'll use this to seed the search.
i i N(
R R t
NULL_REVISIONRR R R R R R2 R R t GhostRevisionsHaveNoRevnoRd ( R t target_revision_idt known_revision_idst known_revnost cur_tipt num_stepsRi t searching_known_tipst unknown_searchedt to_searchR4 Rg t next_known_tipst revision_idt nextt
next_revno( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt find_distance_to_nullW sB
c C@ s˜ i } g } g } xU | D]M } y# | j | | j | | ƒ f ƒ Wq t j k
re | j | ƒ q Xq Wx! | D] } | j | d f ƒ qq Wt | ƒ S( s™ Find the distance to null for all the keys in keys.
:param keys: keys to lookup.
:return: A dict key->distance for all of keys.
iÿÿÿÿ( Rd Rw R Rj R ( R R R5 Rm t ghostsR/ ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt find_lefthand_distancesŒ s
c C@ sÅ | | k r t ƒ S| j | g | ƒ \ } } | j j | j ƒ } | sM | S| j | | | ƒ \ } } | j | | | | ƒ | j | j ƒ } d t j k rÁ t j d t
| ƒ t
| ƒ ƒ n | S( sr Find the unique ancestors for a revision versus others.
This returns the ancestry of unique_revision, excluding all revisions
in the ancestry of common_revisions. If unique_revision is in the
ancestry, then the empty set will be returned.
:param unique_revision: The revision_id whose ancestry we are
interested in.
(XXX: Would this API be better if we allowed multiple revisions on
to be searched here?)
:param common_revisions: Revision_ids of ancestries to exclude.
:return: A set of revisions in the ancestry of unique_revision
RV s% Found %d truly unique nodes out of %d( R t _find_initial_unique_nodesRF RG t _make_unique_searcherst _refine_unique_nodesR t debug_flagsR t muttert len( R t unique_revisiont common_revisionst unique_searchert common_searchert unique_nodest all_unique_searchert unique_tip_searcherst true_unique_nodes( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt find_unique_ancestors¡ s
c C@ sÙ | j | ƒ } | j ƒ | j | ƒ } x¤ | j rÎ t | j ƒ ƒ } t | j ƒ ƒ } | j | j ƒ } | j | j | j ƒ ƒ | r+ | j | ƒ } | j | j | ƒ ƒ | j | ƒ | j
| ƒ q+ q+ W| | f S( sü Steps 1-3 of find_unique_ancestors.
Find the maximal set of unique nodes. Some of these might actually
still be common, but we are sure that there are no other unique nodes.
:return: (unique_searcher, common_searcher)
( RQ Ru t _next_queryR R\ RY RF R R[ RZ t start_searching( R t unique_revisionsR R‚ Rƒ t next_unique_nodest next_common_nodest unique_are_common_nodest ancestors( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRz Ø s"
c
C@ s½ | j | | j | ƒ ƒ } t | ƒ d k rE g } | j | ƒ } nµ g } xe | D]] } | j | g ƒ } | j | j | ƒ ƒ | j | ƒ } | | _ | j ƒ | j | ƒ qR Wd } x> | D]6 } | d k rä t
| j ƒ } qÀ | j | j ƒ } qÀ W| j | ƒ }
| rm|
j ƒ | j
| j | ƒ ƒ } d } x3 | D]( } | t | j
| j | ƒ ƒ ƒ 7} q>Wn d t j k r³t j d t | ƒ t | ƒ | t | ƒ t | ƒ ƒ n |
| f S( s Create a searcher for all the unique search tips (step 4).
As a side effect, the common_searcher will stop searching any nodes
that are ancestors of the unique searcher tips.
:return: (all_unique_searcher, unique_tip_searchers)
i i RV su For %d unique nodes, created %d + 1 unique searchers (%d stopped search tips, %d common ancestors (%d stopped common)N( t _remove_simple_descendantsR R R[ R RQ t _labelR\ Rd R R RF RY RZ R R} R R~ (
R R„ R‚ Rƒ t unique_tipsR† t ancestor_all_uniquet tipt revs_to_searchRW R… t stopped_commont
total_stopped( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR{ ÿ sH
c C@ sÇ t | j ƒ ƒ } t ƒ } xŸ | D]— } t | j ƒ ƒ } | j | j | ƒ ƒ | j | j | ƒ ƒ x6 | D]. } | | k r… qm n | j | j | ƒ ƒ qm W| j | ƒ | j | ƒ q" W| | f S( s Step all the searchers( R R\ R R[ RŠ ( R Rƒ R† R‚ t newly_seen_commont newly_seen_uniqueRW Ru t alt_searcher( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt! _step_unique_and_common_searchers; s
c
C@ s¼ | j ƒ } x | D] } | j | j ƒ q W| j | j ƒ | r¸ t j ƒ } | j ƒ } | j | ƒ d t j k r¸ t j ƒ | } t j
d | t | ƒ t | j ƒ | j ƒ q¸ n | S( sŸ Find nodes that are common to all unique_tip_searchers.
If it is time, step the all_unique_searcher, and add its nodes to the
result.
RV sK all_unique_searcher step() took %.3fsfor %d nodes (%d total), iteration: %s(
t copyt intersection_updateRF t timet clockR\ R R R} R R~ R t _iterations(
R R† R… R™ t step_all_uniquet common_to_all_unique_nodesRW t tstartt nodest tdelta( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt _find_nodes_common_to_all_uniqueM s
c
C@ se i } x– | D]Ž } | j | ƒ } t | j ƒ } | sn d t j k r› t j d | j | j t | ƒ ƒ q› q
| | k rŠ | g | | <q
| | j
| ƒ q
Wg } x¹ | j ƒ D]« } t | ƒ d k rÞ | j
| d ƒ q² | d } x% | d D] } | j j
| j ƒ qó Wd t j k rPt j d t | ƒ t | j ƒ t | j ƒ ƒ n | j
| ƒ q² W| S( sW Combine searchers that are searching the same tips.
When two searchers are searching the same tips, we can stop one of the
searchers. We also know that the maximal set of common ancestors is the
intersection of the two original searchers.
:return: A list of searchers that are searching unique nodes.
RV s@ Unique searcher %s was stopped. (%s iterations) %d nodes stoppedi i sQ Combining %d searchers into a single searcher searching %d nodes with %d ancestry( RZ t frozensetR‰ R R} R R~ R‘ R R Rd t
itervaluesRF R (
R R† R¢ t unique_search_tipsRW t stoppedt will_search_sett next_unique_searchersRK t
next_searcher( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt _collapse_unique_searchersi s6
c
C@ s& d } x| j r!| j | | | ƒ \ } } | j | | | | d k ƒ } | d t } | r{ | j | j j | ƒ ƒ n | r´ | j | j | ƒ ƒ | j | ƒ | j | ƒ n | j
| | ƒ } t | ƒ t | ƒ k rd t j
k rt j d t | ƒ t | ƒ | j ƒ qn | } q Wd S( sŽ Steps 5-8 of find_unique_ancestors.
This function returns when common_searcher has stopped searching for
more nodes.
i i RV s4 Collapsed %d unique searchers => %d at %s iterationsN( R‰ R› R¦ t STEP_UNIQUE_SEARCHER_EVERYRZ RF RY R R[ RŠ R® R R R} R R~ R (
R R‚ R… R† Rƒ t step_all_unique_counterR˜ R™ R¢ R¬ ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR| ž s6
c C@ sC i } x6 | j | ƒ D]% \ } } | d k r | | | <q q W| S( s¯ Get a map of key:parent_list for revisions.
This implementation delegates to get_parents, for old parent_providers
that do not supply get_parent_map.
N( R< R ( R R@ R5 t revRg ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR Ò s
c C@ s
t | | ƒ S( N( t _BreadthFirstSearcher( R R@ ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRQ Þ s c C@ s d | k r! t j d | ƒ ‚ n t ƒ } g | D] } | j | g ƒ ^ q1 } | } t ƒ } xt rt ƒ } x0 | D]( } | j ƒ } | rx | j | ƒ qx qx Wt ƒ }
xk | D]c } | | k rÙ |
j | ƒ q´ n x; | D] } | | j k rà Pqà qà W| j | ƒ |
j | ƒ q´ W|
rvx$ | D] } |
j | j
|
ƒ ƒ q(Wx | D] } | j |
ƒ qOW| j |
ƒ n t ƒ } x9 | D]1 } t | j
ƒ }
|
| k r†| j |
ƒ q†q†Wt | ƒ d k rb | j ƒ } | j | ƒ } | rt d | | f ƒ ‚ n Pqb qb W| | | f S( sW Find common ancestors with at least one uncommon descendant.
Border ancestors are identified using a breadth-first
search starting at the bottom of the graph. Searches are stopped
whenever a node or one of its descendants is determined to be common.
This will scale with the number of uncommon ancestors.
As well as the border ancestors, a set of seen common ancestors and a
list of sets of seen ancestors for each input revision is returned.
This allows calculation of graph difference from the results of this
operation.
i sm Somehow we ended up converging without actually marking them as in common.
Start_nodes: %s
uncommon_nodes: %sN( R R t InvalidRevisionIdR RQ R& R\ R R7 RF R[ RŠ R§ R‰ R t popRG R( ( R R@ t common_ancestorst rRK t active_searcherst border_ancestorst
newly_seenRW t
new_ancestorst
new_commonR t unique_search_setsR« R¤ t uncommon_nodes( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR> á sT "
c
@ s} t | ƒ } t j | k rD | j t j ƒ | sD t t j g ƒ Sn t | ƒ d k rZ | St ‡ f d † | Dƒ ƒ } t | ƒ } x | j ƒ D] } | j ƒ q Wˆ j g ƒ } xÄt | ƒ d k rxt ƒ } y | j ƒ Wn t k
rñ n Xxn | j
ƒ D]` } y | | } Wn t k
r)qÿ n Xy | j | j ƒ ƒ Wqÿ t k
r^| | =qÿ qÿ Xqÿ Wt ƒ } xù | D]ñ }
|
| k r²| j |
ƒ | |
=|
| k r²| |
=q²n |
| j
k r÷t |
g ƒ } x‘ | j ƒ D] } | j | ƒ qÝWqsxj | j ƒ D] } |
| j
k rPqqW| j |
ƒ x3 | j ƒ D]% } | j |
g ƒ } | j | ƒ q;WqsW| j | ƒ qµ W| S( sa Return the heads from amongst keys.
This is done by searching the ancestries of each key. Any key that is
reachable from another key is not returned; all the others are.
This operation scales with the relative depth between any two keys. If
any two keys are completely disconnected all ancestry of both sides
will be retrieved.
:param keys: An iterable of keys.
:return: A set of the heads. Note that as a set there is no ordering
information. Callers will need to filter their input to create
order if they need it.
i c 3@ s' | ] } | ˆ j | g ƒ f Vq d S( N( RQ ( R0 t c( R ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pys <genexpr>B s i ( R R Ri t removeR R R¨ Ru RQ t
StopIterationR t KeyErrorR RF RZ R7 R[ RŠ (
R R t candidate_headsRK R· RW t
common_walkerR t candidateR» t ancestort ancestor_sett seen_ancestors( ( R s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR? + sb
c
C@ s/ t | ƒ d k r t | ƒ St | ƒ } | g } g } t ƒ } xè | r*| r*| j ƒ } | j | ƒ | | k r½ | j | ƒ | j | ƒ t | ƒ d k rC | j | j ƒ ƒ PqC qC n | j | g ƒ j | d ƒ } | sç qC n x= t
| ƒ D]/ } | | k r| j | ƒ n | j | ƒ qô WqC W| S( s¶ Find the order that each revision was merged into tip.
This basically just walks backwards with a stack, and walks left-first
until it finds a node to stop.
i N( R RR R R´ R7 Rd R¿ R R2 R t reversed(
R t tip_revision_idt lca_revision_idst looking_fort stackR R] Ru t
parent_idst parent_id( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt find_merge_order„ s0
c C@ sR | j | | ƒ } | j | ƒ } d } x$ | D] } | | k rD | S| } q. Wd S( s Find the first lefthand ancestor of tip_key that merged merged_key.
We do this by first finding the descendants of merged_key, then
walking through the lefthand ancestry of tip_key until we find a key
that doesn't descend from merged_key. Its child is the key that
merged merged_key.
:return: The first lefthand ancestor of tip_key to merge merged_key.
merged_key if it is a lefthand ancestor of tip_key.
None if no ancestor of tip_key merged merged_key.
N( RX t iter_lefthand_ancestryR ( R t
merged_keyt tip_keyR^ t candidate_iteratort last_candidateRÄ ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt find_lefthand_merger³ s
c C@ sž | | g } d } x… t r™ | d 7} | j | Œ } t | ƒ d k ri | j ƒ } | rb | | f S| Sn t | ƒ d k r t j | | ƒ ‚ n | } q Wd S( s‚ Find a unique LCA.
Find lowest common ancestors. If there is no unique common
ancestor, find the lowest common ancestors of those ancestors.
Iteration stops when a unique lowest common ancestor is found.
The graph origin is necessarily a unique lowest common ancestor.
Note that None is not an acceptable substitute for NULL_REVISION.
in the input for this method.
:param count_steps: If True, the return value will be a tuple of
(unique_lca, steps) where steps is the number of times that
find_lca was run. If False, only unique_lca is returned.
i i N( R& RD R R´ R t NoCommonAncestor( R RH RI t count_stepsR@ t stepst lcaR5 ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt find_unique_lcaÇ s
c #@ s¹ t | ƒ } t ƒ ‰ x | r´ ˆ j | ƒ | j | ƒ } t ƒ } x: | j ƒ D], } | V| j ‡ f d † | d Dƒ ƒ qP W| j | ƒ } x | D] } | d f Vq– W| } q Wd S( sÕ Iterate the ancestry of this revision.
:param revision_ids: Nodes to start the search
:return: Yield tuples mapping a revision_id to its parents for the
ancestry of revision_id.
Ghosts will be returned with None as their parents, and nodes
with no parents will have NULL_REVISION as their only parent. (As
defined by get_parent_map.)
There will also be a node for (NULL_REVISION, ())
c 3@ s! | ] } | ˆ k r | Vq d S( N( ( R0 t p( t processed( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pys <genexpr>ú s i N( R R R t iteritemsRG R ( R t revision_idst pendingt next_mapt next_pendingt itemRx t ghost( ( RÜ s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt
iter_ancestryç s
%
c #@ s | d k r d } n | ‰ ‡ ‡ f d † } xK t rz ˆ | k rF d S| ˆ ƒ } ˆ Vt | ƒ d k rm d S| d ‰ q0 Wd S( Nc @ sE y ˆ j j | g ƒ | SWn# t k
r@ t j ˆ ˆ ƒ ‚ n Xd S( N( R= R RÁ R t RevisionNotPresent( R/ ( t next_keyR ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR< s
i ( ( R R& R ( R t start_keyt stop_keysR< Rg ( ( Ræ R s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRÐ s c C@ s2 d d l m } | j | j | ƒ ƒ } | j ƒ S( s Iterate through the input revisions in topological order.
This sorting only ensures that parents come before their children.
An ancestor may sort after a descendant if the relationship is not
visible in the supplied list of revisions.
i ( t tsort( t bzrlibRé t
TopoSorterR t iter_topo_order( R R@ Ré t sorter( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRì s c C@ s" t | g ƒ | j | | g ƒ k S( sý Determine whether a revision is an ancestor of another.
We answer this using heads() as heads() has the logic to perform the
smallest number of parent lookups to determine the ancestral
relationship between N revisions.
( R R? ( R t candidate_ancestort candidate_descendant( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt is_ancestor s c C@ s: | d k s | j | | ƒ o9 | d k p9 | j | | ƒ S( sš Determine whether a revision is between two others.
returns true if and only if:
lower_bound_revid <= revid <= upper_bound_revid
N( R Rð ( R t revidt lower_bound_revidt upper_bound_revid( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt
is_between( s c C@ sÀ t | ƒ d k r! t d ƒ ‚ n | } | d } | d } | j j | j ƒ } | sZ d St | ƒ } | j | | j | ƒ ƒ } t | ƒ } g } xv | D]n }
|
| j k r¸ | } n | } | j |
g ƒ } | sâ |
g } n | j | ƒ }
|
j ƒ | j |
ƒ qš Wd } x> | D]6 }
| d k r=t |
j ƒ } q| j |
j ƒ } qWt
j d | | ƒ xSt r»t ƒ } x! | D] }
| j |
j ƒ ƒ qWt ƒ } x! | D] }
| j |
j ƒ ƒ q¬Wt ƒ } x? | D]7 } x. | D] }
| |
j k ræPqæqæW| j | ƒ qÙW| r˜x$ | D] }
| j |
j | ƒ ƒ q!Wx | D] }
|
j | ƒ qHW| j | ƒ } | r˜x | D] }
|
j | ƒ q{Wq˜n | r–x$ | D] }
| j |
j | ƒ ƒ q¥Wx$ | D] }
| j |
j | ƒ ƒ qÌWx | D] }
|
j | ƒ qóWx | D] }
|
j | ƒ qW| j | ƒ g } t ƒ } xF | D]> }
t |
j ƒ } | | k rK| j | ƒ | j |
ƒ qKqKW| } n x | D] }
|
j rPqqWd SqiWd S( sb Make sure that unique nodes are genuinely unique.
After _find_border_ancestors, all nodes marked "common" are indeed
common. Some of the nodes considered unique are not, due to history
shortcuts stopping the searches early.
We know that we have searched enough when all common search tips are
descended from all unique (uncommon) nodes because we know that a node
cannot be an ancestor of its own ancestor.
:param common: A set of common nodes
:param searchers: The searchers returned from _find_border_ancestors
:return: None
i s/ Algorithm not yet implemented for > 2 searchersi i Ns3 Started %s unique searchers for %s unique revisions( R t NotImplementedErrorRF t symmetric_differenceR R R[ RQ R\ Rd R R RY R R~ R& R R7 RŠ RZ R§ R‰ ( R RB RK t common_searcherst
left_searchert right_searchert uniquet total_uniquet
simple_uniquet unique_searchersRt t parent_searcherR• RW R“ R˜ R™ t new_common_uniqueR t stop_searching_commonR¬ R¼ R« ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRE 3 s
c C@ sm | j ƒ } xZ | j ƒ D]L \ } } | d k r7 q n x+ | D]# } | | k r> | j | ƒ Pq> q> Wq W| S( sM remove revisions which are children of other ones in the set
This doesn't do any graph searching, it just checks the immediate
parent_map to find if there are any children which can be removed.
:param revisions: A set of revision_ids
:return: A set of revision_ids with the children removed
N( Rœ RÝ R t discard( R R@ R4 t simple_ancestorsR RÍ RÎ ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR Ç s
N(# R R R R R
RD RN RX RP RO Rw Ry Rˆ Rz R{ R› R¦ R® R| R RQ R> R? RÏ RÕ t FalseRÚ Rä R RÐ Rì Rð Rô RE R ( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR; é s> ( 5 7 ' < 5 4 J Y /
”t
HeadsCachec B@ s e Z d Z d „ Z d „ Z RS( s) A cache of results for graph heads calls.c C@ s | | _ i | _ d S( N( RV t _heads( R RV ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR ó s c C@ s_ t | ƒ } y t | j | ƒ SWn7 t k
rZ | j j | ƒ } | | j | <t | ƒ SXd S( s Return the heads of keys.
This matches the API of Graph.heads(), specifically the return value is
a set which can be mutated, and ordering of the input is not preserved
in the output.
:see also: Graph.heads.
:param keys: The keys to calculate heads for.
:return: A set containing the heads, which may be mutated without
affecting future lookups.
N( R§ R R RÁ RV R? ( R R R? ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR? ÷ s
( R R R R R? ( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR ð s t FrozenHeadsCachec B@ s) e Z d Z d „ Z d „ Z d „ Z RS( s; Cache heads() calls, assuming the caller won't modify them.c C@ s | | _ i | _ d S( N( RV R ( R RV ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR s c C@ sY t | ƒ } y | j | SWn7 t k
rT t | j j | ƒ ƒ } | | j | <| SXd S( s- Return the heads of keys.
Similar to Graph.heads(). The main difference is that the return value
is a frozen set which cannot be mutated.
:see also: Graph.heads.
:param keys: The keys to calculate heads for.
:return: A frozenset containing the heads.
N( R§ R RÁ RV R? ( R R R? ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR? s
c C@ s t | ƒ | j t | ƒ <d S( s Store a known value.N( R§ R ( R R R? ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR. % s ( R R R R R? R. ( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR s R² c B@ sƒ e Z d Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z d „ Z
d „ Z d
„ Z d „ Z
d „ Z d
„ Z RS( sô Parallel search breadth-first the ancestry of revisions.
This class implements the iterator protocol, but additionally
1. provides a set of seen ancestors, and
2. allows some ancestries to be unsearched, via stop_searching_any
c C@ sy d | _ t | ƒ | _ t ƒ | _ t | j ƒ | _ t ƒ | _ | | _ d | _ t ƒ | _ t ƒ | _ i | _
d S( Ni t next_with_ghosts( R R R‰ RF t
_started_keyst
_stopped_keysR= t
_returningt _current_presentt _current_ghostst _current_parents( R R@ R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR 2 s c C@ sN | j r d } n d } d | t | j ƒ f } d | j | t | j ƒ f S( Nt searchingt startings %s=%rs1 _BreadthFirstSearcher(iterations=%d, %s, seen=%r)( R RR R‰ RF ( R t prefixt search( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR
> s c C@ sŒ | j d k rO | j | j ƒ \ } } } } | j j | ƒ | j | ƒ } n | j } | j j | ƒ } | j j | ƒ } | j | | f S( sv Get the current state of this searcher.
:return: Tuple with started keys, excludes and included keys
Ru ( R
t _do_queryR‰ RF R t unionR RG R ( R R Rx Ru Rg t
next_queryt excludest
included_keys( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt get_stateG s c C@ s> d d l m } | j ƒ \ } } } | | | t | ƒ | ƒ S( s Get a SearchResult for the current state of this searcher.
:return: A SearchResult for this search so far. The SearchResult is
static - the search can be advanced and the search result will not
be invalidated or altered.
i ( t SearchResult( t bzrlib.vf_searchR R R ( R R t started_keysR R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt _get_result] s c C@ s' y | j ƒ SWn t k
r" d SXd S( N( ( Ru RÀ ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR\ i s
c C@ so | j d k r* d | _ | j d 7_ n
| j ƒ t | j ƒ d k rU t ƒ ‚ n | j j | j ƒ | j S( sJ Return the next ancestors of this revision.
Ancestors are returned in the order they are seen in a breadth-first
traversal. No ancestor will be returned more than once. Ancestors are
returned before their parentage is queried, so ghosts and missing
revisions (including the start revisions) are included in the result.
This can save a round trip in LCA style calculation by allowing
convergence to be detected without reading the data for the revision
the convergence occurs on.
:return: A set of revision_ids.
Ru i i ( R
R t _advanceR R‰ RÀ RF R ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRu o s
c C@ s` | j d k r% d | _ | j ƒ n t | j ƒ d k rF t ƒ ‚ n | j ƒ | j | j f S( s Return the next found ancestors, with ghosts split out.
Ancestors are returned in the order they are seen in a breadth-first
traversal. No ancestor will be returned more than once. Ancestors are
returned only after asking for their parents, which allows us to detect
which revisions are ghosts and which are not.
:return: A tuple with (present ancestors, ghost ancestors) sets.
R i ( R
R R R‰ RÀ R R ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR ‰ s
c C@ se | j d 7_ | j | j ƒ \ } } } } | | _ | | _ | | _ | | _ | j j | ƒ d S( s« Advance the search.
Updates self.seen, self._next_query, self._current_present,
self._current_ghosts, self._current_parents and self._iterations.
i N( R R R‰ R R R
R R ( R R Rx Ru Rg ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR œ s c C@ sË t ƒ } t ƒ } | j } | j | ƒ | j j | ƒ } | j | ƒ xg | j ƒ D]Y \ } } | d k rr qT n g | D] } | | k ry | ^ qy } | rT | j | ƒ qT qT W| | }
| |
| | f S( s Query for revisions.
Adds revisions to the seen set.
:param revisions: Revisions to query.
:return: A tuple: (set(found_revisions), set(ghost_revisions),
set(parents_of_found_revisions), dict(found_revisions:parents)).
N( R RF R R= R RÝ R ( R R@ t found_revisionst parents_of_foundRF R4 t rev_idRg RÛ t new_found_parentst ghost_revisions( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR ¬ s
%
c C@ s | S( N( ( R ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt __iter__È s c C@ sã | j } t | ƒ j | ƒ } t | ƒ } | j d k rE | j } n d } | j | ƒ | j j } xx | rÞ | | ƒ } g } x! | j ƒ D] } | j | ƒ qŒ W| j | ƒ j
| ƒ }
| j |
ƒ |
j | ƒ |
} qg W| S( s Find ancestors of these revisions that have already been seen.
This function generally makes the assumption that querying for the
parents of a node that has already been queried is reasonably cheap.
(eg, not a round trip to a remote host).
Ru ( ( RF R RY R
R‰ R R= R R¨ t extendRG R ( R R@ t all_seenRß RÇ t not_searched_yetR R4 t all_parentsRÍ Rá ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR[ Ë s$
c C@ s³ t | ƒ } | j d k rE | j j | ƒ } | j j | ƒ | _ nJ| j j | ƒ } | j | j j | ƒ ƒ } | j j | ƒ | j j | ƒ i } xO | D]G } x> | j | D]/ } | | k rÒ d | | <n | | c d 7<q³ WqŸ WxP | j j
ƒ D]? } x6 | D]. } y | | c d 8<Wqt k
r4qXqWqú Wt ƒ } x6 | j
ƒ D]( \ } }
|
d k rS| j | ƒ qSqSW| j j | ƒ | j j | ƒ | j j | ƒ | S( s1
Remove any of the specified revisions from the search list.
None of the specified revisions are required to be present in the
search list.
It is okay to call stop_searching_any() for revisions which were seen
in previous iterations. It is the callers responsibility to call
find_seen_ancestors() to make sure that current search tips that are
ancestors of those revisions are also stopped. All explicitly stopped
revisions will be excluded from the search result's get_keys(), though.
Ru i i ( R§ R
R‰ RY RG R R R R R
R¨ RÁ R RÝ R7 R R ( R R@ Rª t stopped_presentt stop_rev_referencesR± RÎ Rg t stop_parentsR t refs( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRZ ñ s:
c C@ sÙ t | ƒ } | j j | ƒ | j | j ƒ } | j d k r` | j j | ƒ | j j | ƒ nu | j | ƒ \ } } } } | j j | ƒ | j j | ƒ | j
j | ƒ | j j | ƒ | j j | ƒ | | f Sd S( sW Add revisions to the search.
The parents of revisions will be returned from the next call to next()
or next_with_ghosts(). If next_with_ghosts was the most recently used
next* call then the return value is the result of looking up the
ghost/not ghost status of revisions. (A tuple (present, ghosted)).
Ru N( R§ R R RG RF R
R‰ R R R R R
( R R@ t
new_revisionst revsRx t queryRg ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRŠ $ s ( R R R R R
R R R\ Ru R R R R" R[ RZ RŠ ( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR² * s & 3c C@ si i } x\ | j ƒ D]N \ } } x? | D]7 } | | k rH | f | | <q& | | | f | | <q& Wq W| S( sC Given a map from child => parents, create a map of parent=>children( RÝ ( R4 RU Rf Rg RÛ ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt invert_parent_map= s
c C@ s_ i } xT | j ƒ D]F \ } } | j | g ƒ x' | D] } | j | g ƒ j | ƒ q6 Wq Wt | ƒ } t ƒ } t | ƒ } xÚ | D]Ò } | | } t | ƒ d k r… | | d } t | ƒ d k rÍ q… n | | }
t |
ƒ d k rï q… n | j |
d d ƒ } t | ƒ d k r q… n | | |
d <|
| | d <| | =| | =| j | ƒ q… q… W| S( s! Collapse regions of the graph that are 'linear'.
For example::
A:[B], B:[C]
can be collapsed by removing B and getting::
A:[C]
:param parent_map: A dictionary mapping children to their parents
:return: Another dictionary with 'linear' chains collapsed
i i N( RÝ Rc Rd R R R R2 R R7 ( R4 t childrenRf Rg RÛ t
orig_childrent removedR5 t nodet parent_childrent
node_childrent
child_parents( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt collapse_linear_regionsL s4 '
!
t GraphThunkIdsToKeysc B@ s; e Z d Z d „ Z d „ Z d „ Z d „ Z d „ Z RS( s7 Forwards calls about 'ids' to be about keys internally.c C@ s
| | _ d S( N( t _graph( R RV ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR ˜ s c C@ s# g | j j ƒ D] \ } | ^ q S( N( R8 t topo_sort( R R¶ ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR9 › s c C@ sO g | D] } | f ^ q } | j j | ƒ } t g | D] } | d ^ q8 ƒ S( s See Graph.heads()i ( R8 R? R ( R t idst it as_keyst head_keyst h( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR? ž s c C@ s: | j j | f ƒ } x | D] } | j d | _ q W| S( Ni ( R8 t
merge_sortR/ ( R t tip_revisionR¤ R2 ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR? ¤ s
c C@ s0 | j j | f g | D] } | f ^ q ƒ d S( N( R8 t add_node( R R Rg RÛ ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyRA ª s ( R R R R R9 R? R? RA ( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyR7 • s ( t
KnownGraph( t
__future__R Rž Rê R R R R R R¯ t objectR R R! R8 R; R R R² R. R6 R7 t _counterst bzrlib._known_graph_pyxRB t ImportErrort et failed_to_load_extensiont bzrlib._known_graph_py( ( ( s0 /usr/lib/python2.7/dist-packages/bzrlib/graph.pyt <module> s2 (4Zÿ ÿ ÿ ÿ ÿ I
Copyright © 2017 || Recoded By Mr.Bumblebee