o h @shdZddlZddlZddlZddlZddlmZddlmZddl Z ddl m Z dgZ dd Zd d d d ZedZeddd ZddlmZmZddejdejdddDe_ed&iddeDe_deej_iZddZddZiZGdddZd d!Z ejd"reZ!d'd#dZe!j"je_e#e!j"Z$e$j%d$de$j&Dd%e_'dSdS)(a& NetworkX utilizes a plugin-dispatch architecture, which means we can plug in and out of backends with minimal code changes. A valid NetworkX backend specifies `entry points `_, named ``networkx.backends`` and an optional ``networkx.backend_info`` when it is installed (not imported). This allows NetworkX to dispatch (redirect) function calls to the backend so the execution flows to the designated backend implementation, similar to how plugging a charger into a socket redirects the electricity to your phone. This design enhances flexibility and integration, making NetworkX more adaptable and efficient. There are three main ways to use a backend after the package is installed. You can set environment variables and run the exact same code you run for NetworkX. You can use a keyword argument ``backend=...`` with the NetworkX function. Or, you can convert the NetworkX Graph to a backend graph type and call a NetworkX function supported by that backend. Environment variables and backend keywords automatically convert your NetworkX Graph to the backend type. Manually converting it yourself allows you to use that same backend graph for more than one function call, reducing conversion time. For example, you can set an environment variable before starting python to request all dispatchable functions automatically dispatch to the given backend:: bash> NETWORKX_AUTOMATIC_BACKENDS=cugraph python my_networkx_script.py or you can specify the backend as a kwarg:: nx.betweenness_centrality(G, k=10, backend="parallel") or you can convert the NetworkX Graph object ``G`` into a Graph-like object specific to the backend and then pass that in the NetworkX function:: H = nx_parallel.ParallelGraph(G) nx.betweenness_centrality(H, k=10) How it works: You might have seen the ``@nx._dispatchable`` decorator on many of the NetworkX functions in the codebase. It decorates the function with code that redirects execution to the function's backend implementation. The code also manages any ``backend_kwargs`` you provide to the backend version of the function. The code looks for the environment variable or a ``backend`` keyword argument and if found, converts the input NetworkX graph to the backend format before calling the backend's version of the function. If no environment variable or backend keyword are found, the dispatching code checks the input graph object for an attribute called ``__networkx_backend__`` which tells it which backend provides this graph type. That backend's version of the function is then called. The backend system relies on Python ``entry_point`` system to signal NetworkX that a backend is installed (even if not imported yet). Thus no code needs to be changed between running with NetworkX and running with a backend to NetworkX. The attribute ``__networkx_backend__`` holds a string with the name of the ``entry_point``. If none of these options are being used, the decorator code simply calls the NetworkX function on the NetworkX graph as usual. The NetworkX library does not need to know that a backend exists for it to work. So long as the backend package creates the entry_point, and provides the correct interface, it will be called when the user requests it using one of the three approaches described above. Some backends have been working with the NetworkX developers to ensure smooth operation. They are the following:: - `graphblas `_ - `cugraph `_ - `parallel `_ - ``loopback`` is for testing purposes only and is not a real backend. Note that the ``backend_name`` is e.g. ``parallel``, the package installed is ``nx-parallel``, and we use ``nx_parallel`` while importing the package. Creating a Custom backend ------------------------- 1. To be a valid backend that is discoverable by NetworkX, your package must register an `entry-point `_ ``networkx.backends`` in the package's metadata, with a `key pointing to your dispatch object `_ . For example, if you are using ``setuptools`` to manage your backend package, you can `add the following to your pyproject.toml file `_:: [project.entry-points."networkx.backends"] backend_name = "your_dispatcher_class" You can also add the ``backend_info`` entry-point. It points towards the ``get_info`` function that returns all the backend information, which is then used to build the "Additional Backend Implementation" box at the end of algorithm's documentation page (e.g. `nx-cugraph's get_info function `_):: [project.entry-points."networkx.backend_info"] backend_name = "your_get_info_function" Note that this would only work if your backend is a trusted backend of NetworkX, and is present in the `.circleci/config.yml` and `.github/workflows/deploy-docs.yml` files in the NetworkX repository. 2. The backend must create an ``nx.Graph``-like object which contains an attribute ``__networkx_backend__`` with a value of the entry point name:: class BackendGraph: __networkx_backend__ = "backend_name" ... Testing the Custom backend -------------------------- To test your custom backend, you can run the NetworkX test suite with your backend. This also ensures that the custom backend is compatible with NetworkX's API. Testing Environment Setup ~~~~~~~~~~~~~~~~~~~~~~~~~ To enable automatic testing with your custom backend, follow these steps: 1. Set Backend Environment Variables: - ``NETWORKX_TEST_BACKEND`` : Setting this to your registered backend key will let the NetworkX's dispatch machinery automatically convert a regular NetworkX ``Graph``, ``DiGraph``, ``MultiGraph``, etc. to their backend equivalents, using ``your_dispatcher_class.convert_from_nx(G, ...)`` function. - ``NETWORKX_FALLBACK_TO_NX`` (default=False) : Setting this variable to `True` will instruct tests to use a NetworkX ``Graph`` for algorithms not implemented by your custom backend. Setting this to `False` will only run the tests for algorithms implemented by your custom backend and tests for other algorithms will ``xfail``. 2. Defining ``convert_from_nx`` and ``convert_to_nx`` methods: The arguments to ``convert_from_nx`` are: - ``G`` : NetworkX Graph - ``edge_attrs`` : dict, optional Dictionary mapping edge attributes to default values if missing in ``G``. If None, then no edge attributes will be converted and default may be 1. - ``node_attrs``: dict, optional Dictionary mapping node attributes to default values if missing in ``G``. If None, then no node attributes will be converted. - ``preserve_edge_attrs`` : bool Whether to preserve all edge attributes. - ``preserve_node_attrs`` : bool Whether to preserve all node attributes. - ``preserve_graph_attrs`` : bool Whether to preserve all graph attributes. - ``preserve_all_attrs`` : bool Whether to preserve all graph, node, and edge attributes. - ``name`` : str The name of the algorithm. - ``graph_name`` : str The name of the graph argument being converted. Running Tests ~~~~~~~~~~~~~ You can invoke NetworkX tests for your custom backend with the following commands:: NETWORKX_TEST_BACKEND= NETWORKX_FALLBACK_TO_NX=True # or False pytest --pyargs networkx Conversions while running tests : - Convert NetworkX graphs using ``.convert_from_nx(G, ...)`` into the backend graph. - Pass the backend graph objects to the backend implementation of the algorithm. - Convert the result back to a form expected by NetworkX tests using ``.convert_to_nx(result, ...)``. Notes ~~~~~ - Dispatchable algorithms that are not implemented by the backend will cause a ``pytest.xfail``, giving some indication that not all tests are running, while avoiding causing an explicit failure. - If a backend only partially implements some algorithms, it can define a ``can_run(name, args, kwargs)`` function that returns True or False indicating whether it can run the algorithm with the given arguments. It may also return a string indicating why the algorithm can't be run; this string may be used in the future to give helpful info to the user. - A backend may also define ``should_run(name, args, kwargs)`` that is similar to ``can_run``, but answers whether the backend *should* be run (converting if necessary). Like ``can_run``, it receives the original arguments so it can decide whether it should be run by inspecting the arguments. ``can_run`` runs before ``should_run``, so ``should_run`` may assume ``can_run`` is True. If not implemented by the backend, ``can_run`` and ``should_run`` are assumed to always return True if the backend implements the algorithm. - A special ``on_start_tests(items)`` function may be defined by the backend. It will be called with the list of NetworkX tests discovered. Each item is a test object that can be marked as xfail if the backend does not support the test using ``item.add_marker(pytest.mark.xfail(reason=...))``. - A backend graph instance may have a ``G.__networkx_cache__`` dict to enable caching, and care should be taken to clear the cache when appropriate. N)partial) entry_points)argmap _dispatchablecCdS)zKThis does nothing at all, yet it helps turn `_dispatchable` into functions.NrrrR/var/www/html/env_mimamsha/lib/python3.10/site-packages/networkx/utils/backends.py _do_nothingsr F) load_and_callc Cst|d}i}|D]G}|j|vrtjd|jtddq |rKz |||j<Wq tyJ}ztjd|jd|tddWYd}~q d}~ww|||j<q |dd|S) a Retrieve NetworkX ``backends`` and ``backend_info`` from the entry points. Parameters ----------- group : str The entry_point to be retrieved. load_and_call : bool, optional If True, load and call the backend. Defaults to False. Returns -------- dict A dictionary mapping backend names to their respective backend objects. Notes ------ If a backend is defined more than once, a warning is issued. The `nx-loopback` backend is removed if it exists, as it is only available during testing. A warning is displayed if an error occurs while loading a backend. )groupz)networkx backend defined more than once: ) stacklevelz0Error encountered when loading info for backend z: Nz nx-loopback)rnamewarningswarnRuntimeWarningload Exceptionpop)r r itemsrvepexcrrr _get_backendss.     rznetworkx.backendsznetworkx.backend_infoT)ConfigconfigcCsg|] }|r|qSr)strip.0xrrr s r!NETWORKX_BACKEND_PRIORITYNETWORKX_AUTOMATIC_BACKENDS,cCsDi|]\}}|d|vrt|datrtn tditntqS)default_configr) isinstancecfgrrbackendinforrr s$r,z2All installed NetworkX backends and their configs.cCr)NTr)rargskwargsrrr _always_run"sr/cCsH|tvrt|St|}t|<t|dst|_t|ds"t|_|S)Ncan_run should_run)_loaded_backendsbackendsrhasattrr/r0r1) backend_namerrrr _load_backend&s  r6c @seZdZdZdZejdd dkZ d#ddddddddddd dd Z e d d Zej d d Ze d dZddddZddZddZddZddZddddZddddZdd Zd!d"ZdS)$raAllow any of the following decorator forms: - @_dispatchable - @_dispatchable() - @_dispatchable(name="override_name") - @_dispatchable(graphs="graph") - @_dispatchable(edge_attrs="weight") - @_dispatchable(graphs={"G": 0, "H": 1}, edge_attrs={"weight": "default"}) These class attributes are currently used to allow backends to run networkx tests. For example: `PYTHONPATH=. pytest --backend graphblas --fallback-to-nx` Future work: add configuration to control these. FNETWORKX_FALLBACK_TO_NXtrueNG rgraphs edge_attrs node_attrspreserve_edge_attrspreserve_node_attrspreserve_graph_attrspreserve_all_attrs mutates_input returns_graphc s |durtt||||||| | | d St|trtdddur$|jt||j_|j_|j r?i|j ddi_ nddi_ |j _ |j _ j |j |_|j_d_|__|_|_|pl| _|pq| _|pv| _| _| _|durt|ttBstdt|dd|durt|ttBstdt|ddtjttBtBstdtjd dtjttBtBstd tjd dtjttBstd tjd dtjttBstd tjddtjtstdtjddt|tr|di}n#|dur"nt|ts3tdt|ddt|dkr?t ddt_!t_"|durPi_#nfdd|$D_#d_%fddt&$D_'t(vrzt ddt)t*t(<S)aA decorator that makes certain input graph types dispatch to ``func``'s backend implementation. Usage can be any of the following decorator forms: - @_dispatchable - @_dispatchable() - @_dispatchable(name="override_name") - @_dispatchable(graphs="graph_var_name") - @_dispatchable(edge_attrs="weight") - @_dispatchable(graphs={"G": 0, "H": 1}, edge_attrs={"weight": "default"}) with 0 and 1 giving the position in the signature function for graph objects. When edge_attrs is a dict, keys are keyword names and values are defaults. The class attributes are used to allow backends to run networkx tests. For example: `PYTHONPATH=. pytest --backend graphblas --fallback-to-nx` Future work: add configuration to control these. Parameters ---------- func : callable, optional The function to be decorated. If ``func`` is not provided, returns a partial object that can be used to decorate a function later. If ``func`` is provided, returns a new callable object that dispatches to a backend algorithm based on input graph types. name : str, optional The name of the algorithm to use for dispatching. If not provided, the name of ``func`` will be used. ``name`` is useful to avoid name conflicts, as all dispatched algorithms live in a single namespace. For example, ``tournament.is_strongly_connected`` had a name conflict with the standard ``nx.is_strongly_connected``, so we used ``@_dispatchable(name="tournament_is_strongly_connected")``. graphs : str or dict or None, default "G" If a string, the parameter name of the graph, which must be the first argument of the wrapped function. If more than one graph is required for the algorithm (or if the graph is not the first argument), provide a dict of parameter name to argument position for each graph argument. For example, ``@_dispatchable(graphs={"G": 0, "auxiliary?": 4})`` indicates the 0th parameter ``G`` of the function is a required graph, and the 4th parameter ``auxiliary`` is an optional graph. To indicate an argument is a list of graphs, do e.g. ``"[graphs]"``. Use ``graphs=None`` if *no* arguments are NetworkX graphs such as for graph generators, readers, and conversion functions. edge_attrs : str or dict, optional ``edge_attrs`` holds information about edge attribute arguments and default values for those edge attributes. If a string, ``edge_attrs`` holds the function argument name that indicates a single edge attribute to include in the converted graph. The default value for this attribute is 1. To indicate that an argument is a list of attributes (all with default value 1), use e.g. ``"[attrs]"``. If a dict, ``edge_attrs`` holds a dict keyed by argument names, with values that are either the default value or, if a string, the argument name that indicates the default value. node_attrs : str or dict, optional Like ``edge_attrs``, but for node attributes. preserve_edge_attrs : bool or str or dict, optional For bool, whether to preserve all edge attributes. For str, the parameter name that may indicate (with ``True`` or a callable argument) whether all edge attributes should be preserved when converting. For dict of ``{graph_name: {attr: default}}``, indicate pre-determined edge attributes (and defaults) to preserve for input graphs. preserve_node_attrs : bool or str or dict, optional Like ``preserve_edge_attrs``, but for node attributes. preserve_graph_attrs : bool or set For bool, whether to preserve all graph attributes. For set, which input graph arguments to preserve graph attributes. preserve_all_attrs : bool Whether to preserve all edge, node and graph attributes. This overrides all the other preserve_*_attrs. mutates_input : bool or dict, default False For bool, whether the functions mutates an input graph argument. For dict of ``{arg_name: arg_pos}``, arguments that indicates whether an input graph will be mutated, and ``arg_name`` may begin with ``"not "`` to negate the logic (for example, this is used by ``copy=`` arguments). By default, dispatching doesn't convert input graphs to a different backend for functions that mutate input graphs. returns_graph : bool, default False Whether the function can return or yield a graph object. By default, dispatching doesn't convert input graphs to a different backend for functions that return graphs. Nr:z-'name' and 'graphs' must be passed by keywordr*zBad type for edge_attrs: z. Expected str or dict.zBad type for node_attrs: z"Bad type for preserve_edge_attrs: z. Expected bool, str, or dict.z"Bad type for preserve_node_attrs: z#Bad type for preserve_graph_attrs: z. Expected bool or set.zBad type for mutates_input: z. Expected bool or dict.zBad type for returns_graph: z. Expected bool.rzBad type for graphs: z0'graphs' must contain at least one variable namecsfi|]/\}}|ddkrj|ddpndkr.j|ddp-n||qS)?N]r)optional_graphsadd list_graphsrkv)lastselfvalrr r,sz)_dispatchable.__new__..cs(h|]\}}d|vr|dvr|qS) functionsrr)rrr )s z(_dispatchable.__new__..z/Algorithm already exists in dispatch registry: )+rrr'str TypeError__name__object__new__ __defaults____kwdefaults__ __module__ __qualname____dict__update __wrapped____doc__ _orig_doc _cached_doc orig_funcrr<r=r>r?r@rB_returns_graphdicttypeboolsetlenKeyErrorrGrIr;r_sig backend_infor3_registered_algorithmsrr ) clsfuncrr;r<r=r>r?r@rArBrCr)rMrrNrOr rWGsj               z_dispatchable.__new__cCs$|j}dur |S|}|_|S)zIf the cached documentation exists, it is returned. Otherwise, the documentation is generated using _make_doc() method, cached, and then returned.N)ra _make_doc)rNrrrr r_;sz_dispatchable.__doc__cCs||_d|_dS)z_Sets the original documentation to the given value and resets the cached documentation.N)r`ra)rNrOrrr r_Fs cCs|jdurTt|j}tdd|jDs5|jg|jtjdtjj ddtdtjj d}n|j^}}|jg|tjdtjj dd|d}||_|jS)zzReturn the signature of the original function, with the addition of the `backend` and `backend_kwargs` parameters.Ncss|] }|jtjjkVqdSN)kindinspect Parameter VAR_KEYWORD)rprrr Ws z._dispatchable.__signature__..r*)defaultbackend_kwargs parameters) rjrr signaturerbanyrzvaluesreplacers KEYWORD_ONLYrt)rNsigrz var_keywordrrr __signature__Ns@      z_dispatchable.__signature__)r*c sts jiS|}|dur|tvrtd|i}jD]O\}}|tkr?|vr:tjd||}n|vrH|}n|jvrWtjd|q"|durm|jvrltjd|dq"|||<q"j rt j | @D]}t ||}|||<|vr||<q|j|<qt fdd|D} | r͇fd d |D} j | @D]}| d d||Dqnt d d|D} | rd d |D} tj} jr| r|durj| djdS| r| dh} t| dkrtjd| | \} |dur0|| kr0tjd| d|d| tvr..N)rIr4r|rgnamegrNrr rvs  z)_dispatchable.__call__..cs&h|]\}}|jvrt|ddqSrnetworkx)rIgetattrrrrr rRs   z)_dispatchable.__call__..css|] }t|ddVqdS)rrNrrrrrr rvs  csrrrrrrr rvs  cSsh|]}t|ddqSrrrrrr rRs rfallback_to_nxrrz3() graphs must all be from the same backend, found z+() is unable to convert graph from backend z to the specified backend .z!Unable to convert inputs and run z. z() has networkx and zY graphs, but NetworkX is not configured to automatically convert graphs from networkx to '' not implemented by Fc3sj|]0\}}|dr t|kr|n |ddd nt|kr*|n|duVqdS)znot NT) startswithrhget)rarg_namearg_pos)r-r.rr rvs   )r3rb ImportErrorr;rrhrTrrGrIlistkeysr|r]r}rbackend_priority _is_testing_convert_and_call_for_tests_fallback_to_nxr6r4_convert_and_callrnxNetworkXNotImplementedrcrBr'rd_should_backend_run)rNr*r-r.r5graphs_resolvedrposrO has_backendsgraph_backend_namesr backend_namesgraph_backend_namer)r-r.rNr __call__ss                        z_dispatchable.__call__cOs4t|}t||jo||j||}ot|t S)zBCan the specified backend run this algorithm with these arguments?)r6r4rr0r'rS)rNr5r-r.r*r0rrr _can_backend_run*s   z_dispatchable._can_backend_runcOsTt|}t||jo)||j||}o)t|t o)||j||}o)t|t S)zICan/should the specified backend run this algorithm with these arguments?)r6r4rr0r'rSr1)rNr5r-r.r*r0r1rrr r5s   z!_dispatchable._should_backend_runc s jj|i| jsj}|d=j|fS j jdur&n?dur-dn8tt rej dus@t j rEddn j durctt rUks^tt rcvrcddnddurjn]tt rddkrddj d d DnCt j rddn7j durj d in( j d krtj d d rddj d jDndn fddD j j durnE durdn>t t rj dust j rd dn%j durtt r kstt r vrd dnd durnHtt rYddkr9ddj d d Dn,t j rFd dnj durVj dindn fddD j jD] jvr f ddj Dj <qkj }|dur jvrqktdd j dtt rd}}n}}t t rd} } n } } ttrۈv} n} t|dddkr j||| || |  d j <qkj}|d=j|fS)z~Convert graph arguments to the specified backend. Returns ------- args tuple and kwargs dict r*FTNr[cSi|]}|dqSrrr edge_attrrrr r,xz4_dispatchable._convert_arguments..rrDto_numpy_arraydtypenamescSrrrrrrr r,rcs@i|]\}}j|durt|trj|dn|qS)Nr argumentsr'rSrrkeyrO)boundrrr r,s cSrrpr)r node_attrrrr r,rcs>i|]\}}j|durt|trj|n|qSrprr)rrrr r,s c s<g|]}t|dddkrj|d n|qS)rrr<r=r>r?r@ graph_name use_cache)r_convert_graphr) r5r<rr=r>r@r?rNrrr r!s  z4_dispatchable._convert_arguments..z!Missing required graph argument `z` in z functionrrr)rbindapply_defaultsr;r.r-r>r<r'rSrcallablerdrr4rrr?r=r@rIrGrTrrgrr) rNr5r-r.r bound_kwargsgraphpreserve_edgesedgespreserve_nodesnodespreserve_graphr) r5rrr<rrr=r>r@r?rNrr _convert_argumentsBs                          z _dispatchable._convert_argumentsc Csr| rt|dd} dur| di|i} |dur t|n||dur+t|n||f} \} }}| rd|d|jd}t| durJ| dfnd|durS|dfnd|dur\|dfndD]}| |}durst ||Sq_| dur|durt | D]B\\}}}}| dus|durn| dus|dus| |sq|dus|durn|dus|dus| |sq|r|sqt ||St |}|j |||||||j|d }| r7| dur7|| | <t | D]O}|| krq|\}}}|dus| durn|dus | dus | | s q|dus|durn|dus(|dus(| |s)q|r0|s0q| |dq|S) N__networkx_cache__r3zUsing cached graph for z backend in call to a. For the cache to be consistent (i.e., correct), the input graph must not have been manually mutated since the cached graph was created. Examples of manually mutating the graph data structures resulting in an inconsistent cache include: >>> G[u][v][key] = val and >>> for u, v, d in G.edges(data=True): ... d[key] = val Using methods such as `G.add_edge(u, v, weight=val)` will correctly clear the cache to keep it consistent. You may also use `G.__networkx_cache__.clear()` to manually clear the cache, or set `G.__networkx_cache__` to None to disable caching for G. Enable or disable caching via `nx.config.cache_converted_graphs` config.T)TF)r<r=r>r?r@rr)r setdefault frozensetrr itertoolsproductrrrrissubsetr6convert_from_nxr)rNr5rr<r=r>r?r@rrnx_cachecacheredge_keynode_key graph_keywarning_message compat_keyrekeynkeygkeyrOr*cur_keyrrr rs           z_dispatchable._convert_graphrc Cst|}|j|g|Ri|s1|r|j|i|Sd|jd|}t||jr-|d7}t|z|j|||tjd\}}t ||j|i|} W| St t j fyk} z|rf|j|i|WYd} ~ Sd} ~ ww)zOCall this dispatchable function with a backend, converting graphs if necessary.rr with the given argumentsrN) r6rrbrr4 RuntimeErrorrrcache_converted_graphsrNotImplementedErrorrr) rNr5r-r.rr*msgconverted_argsconverted_kwargsresultrrrr rs(   z_dispatchable._convert_and_callc sLt|} j|g|Ri|s9|s js j|i|Sddl}d jd|}t| jr4|d7}||ddlm m m ddl m ddl mmmm dd lmdd lmddl dd lmmdd lm|sz|}} nt f d d|D\}} |s|} } n!t f dd|D\} } t| } t| } z j||| dd\} } t | j| i| }Wn@t!t"j#fy}z0|r j| i| WYd}~Sddl}||j$r|j$dn jdt%|j&WYd}~nd}~ww j't(|t"j)p0t|dp0t(|t*t+Bo0t,dd|Dkra jdvrCt,dd|Dsa jdvrSt,dd|Dsa jdvrat-d jd5 fdd fdd} jdvr|n4t(|r||}n)z |Wnt-y}zt- jd |d!t%|d"|d}~ww | jd#vr@ j.j/| i| }|0 j.j/| i| }|0 jd$vr|1|j2d%}|j2d%}|j3|_3t"4|nM jd&kr-|1|j2d'}|j2d'}|dur+|dur+|j5D]\}}|d(|j5|d(<q|j67|j6t"4|n jd)krg|j2d*durg|1|j2d%}|j2d%}|j2d*}|j8D]\}}|||j8||<qRt"4|nԈ jd+vr|j2d,s|1|j2d%}|j2d%}|j97|j9t"4|n jd-kr|j2d,s|1|j2d%}|j2d%}|j5D]\}}|d.|j5|d.<qt"4|n{ jd/kr|j2d,r҈ jd0vr;|1|j2d%}|j2d%}||ur|S|j:;|j:7|j:|j3;|j37|j3t|d1rt|d1r|j<;|j<7|j<t|d2r.t|d2r.|j=;|j=7|j=t"4| jd/kr;|S|1|S|1|}t(|t"j)r jd3vr j| i| }t"j>?||s|@|@ksmJ|A|AksxJ|j6|j6ksJ|j8|j8ksJ|jB|jBksJt%|t%|usJtCd4|S|S)6zECall this dispatchable function with a backend; for use with testing.rNrrr)IterableIteratorMapping)copy)BufferedReaderBytesIOStringIO TextIOWrapper)tee)Random) Generator RandomState)sparrayc3s^|]*}t|BBBBr||fnt|r't|Bs' |n||fVqdSrpr')rarg) rrrrrrrrrrrr rvs    z<_dispatchable._convert_and_call_for_tests..c3s|]@\}}t|BBBBr||f||ffn#t|r9t|Bs9| | df| dffn||f||ffVqdS)rrNrrJ) rrrrrrrrrrteedrr rvs  " Frz raised rcss&|]}t|tjpt|dVqdSr)r'rGraphr4rrrr rvs  >check_planaritycheck_planarity_recursivecss|]}|duVqdSrprrrrr rvs>held_karp_ascentcss|]}t|tVqdSrp)r'rdrrrr rvr> all_triadsnonisomorphic_treesgeneral_k_edge_subgraphsz!`returns_graph` is incorrect for c st|jrtjd|dt|d|dt|jBr#dSt|tjr=|j|dd|j |dddSt|rDt t|r[t|t s[|D] }||ddqPt|ro| D] }||ddqddSdS)N returned a numpy scalar  (z, depth=)r)depth) r'numberrrrendarrayrr_node_adjrrSr})rOrr )rrr check_resultnprNrrr rs(      z?_dispatchable._convert_and_call_for_tests..check_resultc 3s^|D])}z|Wnty(}ztjd|dt|d|d}~ww|VqdS)Nrrr)rrre)itrOr)rrNrr check_iterator's zA_dispatchable._convert_and_call_for_tests..check_iterator> from_edgelistrrr> barycenter edmonds_karp relabel_nodescontracted_edgecontracted_nodesstochastic_graphmaximum_branchingminimal_branchingrecursive_simple_cyclesconnected_double_edge_swapminimum_spanning_arborescence incremental_closeness_centrality>rrrrr9r residualflowr attr>rrrrweightr>r_pred_succ>read_gml read_gexf from_pydot read_pajek read_graph6 preflow_push read_adjlist read_graphml read_sparse6 read_edgelistpydot_read_dotquotient_graphagraph_read_dotboykov_kolmogorovspectral_graph_forgeread_multiline_adjlistbipartite_read_edgelistshortest_augmenting_pathzGraphs are not equal)r)Dr6rr;rbpytestrr4xfailcollections.abcrrrriorrrrrrrandomrnumpy numpy.randomrr scipy.sparserziprrdrrrrrr-rerUrcr'rtuplerr|rrrr convert_to_nxrr _clear_cacherrr]rr\rclearrrutils graphs_equalnumber_of_nodesnumber_of_edgesadjAssertionError)rNr5r-r.rr*r0rargs1args2kwargs1kwargs2rrrrr rbound2G1G2R1R2rKrLrconverted_resultr9r)rrrrrrrrrrrrrrNrrrr rs:             $                                  z)_dispatchable._convert_and_call_for_testsc Cs|js|jSddg}t|jD]}t|}d|vr&||d|dn||d|vs6|j|dvr<|dq|d|j}|dpL|d}r_|d d |d Dd }nd }|dpj|d}r|rt|d|dt|D]}|d|||} r|d| |dq}n|d|d} r|d| d|dq| d |} |j d| S)zGenerate the backends section at the end for functions having an alternate backend implementation(s) using the `backend_info` entry-point.Backendsz-------- short_summaryz : rPr$additional_docsextra_docstringcss"|] }|r d|n|VqdS)z Nr)rlinerrr rvs z*_dispatchable._make_doc.. TFextra_parametersadditional_parametersz Additional parameters:z z urlz [`Source `_]z z ) r3r`sortedrkappendrrextendsplitrjoinrstrip) rNlinesr*r+ func_info func_docsadd_gaprSparamdescfunc_urlto_addrrr rosR            z_dispatchable._make_doccCs t|jffS)zAllow this object to be serialized with pickle. This uses the global registry `_registered_algorithms` to deserialize. )_restore_dispatchablerrrrr __reduce__s z_dispatchable.__reduce__rp)rUrZr[r_rosenvironrrlowerrrWpropertysetterrrrrrrrrrorerrrr r4sN  u   $8  O}  9cCst|Srp)rlrQrrr rdsrd_NETWORKX_BUILDING_DOCS_cKs4|dur ttfi|St|fi|}|j|_|Srp)rr_orig_dispatchabler_)rnr.dispatched_funcrrr rs cCsg|] \}}|dkr|qS)rmrrJrrr r!sryrrp)(r_rrrrfr functoolsrimportlib.metadatarrr decoratorsr__all__r rr3rkconfigsrrrgrrYrrrer2r/r6rlrrdrlrWr{rjr~rzrrrrr sjB   .     O