btj>> import networkx as nx >>> nx.utils.make_list_of_ints({1, 2, 3}) [1, 2, 3] >>> nx.utils.arbitrary_element({5, 1, 7}) # doctest: +SKIP 1 N) defaultdict)IterableIteratorSized)chaintee zip_longest)flattenmake_list_of_intsdict_to_numpy_arrayarbitrary_elementpairwisegroupscreate_random_statecreate_py_random_statePythonRandomInterfacePythonRandomViaNumpyBits nodes_equal edges_equal graphs_equal _clear_cachecJt|ttzrt|tr|S|g}|D]Z}t|ttzrt|tr||Jt ||[t |S)z>Return flattened version of (possibly nested) iterable object.) isinstancerrstrappendr tuple)objresultitems Q/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/networkx/utils/misc.pyr r .s c8e+ , , 30D0D  ~""$5 011 "Zc5J5J " MM$     D& ! ! ! ! ==ct|tsqg}|D]j}d|} t|}n##t$rt j|dwxYw||krt j|||k|St|D]s\}}d|}t|tr t|}n##t$rt j|dwxYw||krt j||||<t|S)a*Return list of ints from sequence of integral numbers. All elements of the sequence must satisfy int(element) == element or a ValueError is raised. Sequence is iterated through once. If sequence is a list, the non-int values are replaced with ints. So, no new list is created zsequence is not all integers: N)rlistint ValueErrornx NetworkXErrorr enumerate)sequencerierrmsgiiindxs r r r <sR h % %   A9a99F 9VV 9 9 9&v..D8 9Qww&v... MM"     X&&  a5!55 a     5QBB 5 5 5"6** 4 5 77"6** * Os2 A7C C'cr t||S#ttf$rt||cYSwxYw)zPConvert a dictionary of dictionaries to a numpy array with optional mapping.)_dict_to_numpy_array2AttributeError TypeError_dict_to_numpy_array1)dmappings r r r `sO1$Q000 I &111%Q000001s !66c @ddl}|t|}|D],\}}||-t t |tt|}t|}| ||f}|D]C\}} |D])\} } ||| || | f<#t$rY&wxYwD|S)zYConvert a dictionary of dictionaries to a 2d numpy array with optional mapping. rN) numpysetkeysitemsupdatedictziprangelenzerosKeyError) r3r4npskvnak1r*k2js r r/r/ks!  MMGGII  DAq HHQVVXX    s1eCFFmm,,-- G A !QAA]]__  EB B%)!Q$      Hs9D  DDc dddl}|Xt|}tt |t t |}t |}||}|D]\}}||}||||<|S)zJConvert a dictionary of numbers to a 1d numpy array with optional mapping.rN) r6r7r8r;r<r=r>r?r9)r3r4rArBrErFrGr*s r r2r2s MMs1eCFFmm,,-- G A  AA BKu! Hr!ct|trtdtt |S)aReturns an arbitrary element of `iterable` without removing it. This is most useful for "peeking" at an arbitrary element of a set, but can be used for any list, dictionary, etc., as well. Parameters ---------- iterable : `abc.collections.Iterable` instance Any object that implements ``__iter__``, e.g. set, dict, list, tuple, etc. Returns ------- The object that results from ``next(iter(iterable))`` Raises ------ ValueError If `iterable` is an iterator (because the current implementation of this function would consume an element from the iterator). Examples -------- Arbitrary elements from common Iterable objects: >>> nx.utils.arbitrary_element([1, 2, 3]) # list 1 >>> nx.utils.arbitrary_element((1, 2, 3)) # tuple 1 >>> nx.utils.arbitrary_element({1, 2, 3}) # set 1 >>> d = {k: v for k, v in zip([1, 2, 3], [3, 2, 1])} >>> nx.utils.arbitrary_element(d) # dict_keys 1 >>> nx.utils.arbitrary_element(d.values()) # dict values 3 `str` is also an Iterable: >>> nx.utils.arbitrary_element("hello") 'h' :exc:`ValueError` is raised if `iterable` is an iterator: >>> iterator = iter([1, 2, 3]) # Iterator, *not* Iterable >>> nx.utils.arbitrary_element(iterator) Traceback (most recent call last): ... ValueError: cannot return an arbitrary item from an iterator Notes ----- This function does not return a *random* element. If `iterable` is ordered, sequential calls will return the same value:: >>> l = [1, 2, 3] >>> nx.utils.arbitrary_element(l) 1 >>> nx.utils.arbitrary_element(l) 1 z0cannot return an arbitrary item from an iterator)rrr%nextiter)iterables r r r s;~(H%%MKLLL X  r!Fc|stj|St|\}}t|d}t |t ||fS)aReturn successive overlapping pairs taken from an input iterable. Parameters ---------- iterable : iterable An iterable from which to generate pairs. cyclic : bool, optional (default=False) If `True`, a pair with the last and first items is included at the end. Returns ------- iterator An iterator over successive overlapping pairs from the `iterable`. See Also -------- itertools.pairwise Examples -------- >>> list(nx.utils.pairwise([1, 2, 3, 4])) [(1, 2), (2, 3), (3, 4)] >>> list(nx.utils.pairwise([1, 2, 3, 4], cyclic=True)) [(1, 2), (2, 3), (3, 4), (4, 1)] N) itertoolsrrrLr<r)rNcyclicrFbfirsts r rrsU8 ,!(+++ x==DAq DMME q%E8$$ % %%r!ctt}|D] \}}|||!t |S)aConverts a many-to-one mapping into a one-to-many mapping. `many_to_one` must be a dictionary whose keys and values are all :term:`hashable`. The return value is a dictionary mapping values from `many_to_one` to sets of keys from `many_to_one` that have that value. Examples -------- >>> from networkx.utils import groups >>> many_to_one = {"a": 1, "b": 1, "c": 2, "d": 3, "e": 3} >>> groups(many_to_one) # doctest: +SKIP {1: {'a', 'b'}, 2: {'c'}, 3: {'e', 'd'}} )rr7r9addr;) many_to_one one_to_manyrDrCs r rrsY c""K!!##1A1   r!c8ddl}| ||jur|jjjSt ||jjr|St |t r|j|St ||jjr|S|d}t|)aReturns a numpy.random.RandomState or numpy.random.Generator instance depending on input. Parameters ---------- random_state : int or NumPy RandomState or Generator instance, optional (default=None) If int, return a numpy.random.RandomState instance set with seed=int. if `numpy.random.RandomState` instance, return it. if `numpy.random.Generator` instance, return it. if None or numpy.random, return the global random number generator used by numpy.random. rNzW cannot be used to create a numpy.random.RandomState or numpy.random.Generator instance) r6randommtrand_randr RandomStater$ Generatorr% random_staterAmsgs r rrs|ry88y%%, 566,$$3y$$\222, 344  * * * S//r!c8eZdZdZd dZdZdZdZdZdZ dS) raProvide the random.random algorithms using a numpy.random bit generator The intent is to allow people to contribute code that uses Python's random library, but still allow users to provide a single easily controlled random bit-stream for all work with NetworkX. This implementation is based on helpful comments and code from Robert Kern on NumPy's GitHub Issue #24458. This implementation supersedes that of `PythonRandomInterface` which rewrote methods to account for subtle differences in API between `random` and `numpy.random`. Instead this subclasses `random.Random` and overwrites the methods `random`, `getrandbits`, `getstate`, `setstate` and `seed`. It makes them use the rng values from an input numpy `RandomState` or `Generator`. Those few methods allow the rest of the `random.Random` methods to provide the API interface of `random.random` while using randomness generated by a numpy generator. Nc ddl}n,#t$rd}tj|tYnwxYw||jjj|_n||_d|_ dSNrz.numpy not found, only random.random available.) r6 ImportErrorwarningswarn ImportWarningrYrZr[_rng gauss_nextselfrngrAr`s r __init__z!PythonRandomViaNumpyBits.__init__?sz .      . . .BC M#} - - - - - . ; (.DIIDI &00c4|jS)z7Get the next random number in the range 0.0 <= X < 1.0.rhrYrks r rYzPythonRandomViaNumpyBits.randomOsy!!!r!c|dkrtd|dzdz}t|j|d}||dz|z z S)z:getrandbits(k) -> x. Generates an int with k random bits.rz#number of bits must be non-negativebig)r%r$ from_bytesrhbytes)rkrCnumbytesxs r getrandbitsz$PythonRandomViaNumpyBits.getrandbitsSs\ q55BCC CEa< NN49??844e < <X\A%&&r!c4|jSN)rh __getstate__rqs r getstatez!PythonRandomViaNumpyBits.getstate[sy%%'''r!c:|j|dSr|)rh __setstate__)rkstates r setstatez!PythonRandomViaNumpyBits.setstate^s u%%%%%r!c td)zDo nothing override method.z2seed() not implemented in PythonRandomViaNumpyBits)NotImplementedError)rkargskwdss r seedzPythonRandomViaNumpyBits.seedas!"VWWWr!r|) __name__ __module__ __qualname____doc__rmrYrzr~rrr!r rr-s" """'''(((&&&XXXXXr!rcXeZdZdZddZdZdZddZdZdZ d Z d Z d Z d Z d ZdS)rz{PythonRandomInterface is included for backward compatibility New code should use PythonRandomViaNumpyBits instead. Nc ddl}n,#t$rd}tj|tYnwxYw||jjj|_dS||_dSrc) r6rdrerfrgrYrZr[rhrjs r rmzPythonRandomInterface.__init__lss .      . . .BC M#} - - - - - . ; (.DIIIDIIIrnc4|jSr|rprqs r rYzPythonRandomInterface.randomxsy!!!r!cF|||z |jzzSr|rp)rkrFrRs r uniformzPythonRandomInterface.uniform{s$AETY--/////r!c ddl}|d|}}|dkr*t|j}|||St |j|jjr|j||S|j||S)Nr) r6rrh randrangerrYr]integersrandintrkrFrRrAtmp_rngs r rzPythonRandomInterface.randrange~s 9aqA " " ".ty99G$$Q** * di!4 5 5 ,9%%a++ +y  A&&&r!cddl}t|j|jjr)|jdt |}n(|jdt |}||S)Nr)r6rrhrYr]rr>r)rkseqrAidxs r choicezPythonRandomInterface.choicesl di!4 5 5 1)$$QC11CC)##As3xx00C3xr!c8|j||Sr|)rhnormal)rkmusigmas r gausszPythonRandomInterface.gausssyE***r!c6|j|Sr|)rhshuffle)rkrs r rzPythonRandomInterface.shufflesy  %%%r!cX|jt||fdS)NF)sizereplace)rhrr#)rkrrCs r samplezPythonRandomInterface.samples'yS eDDDr!c ddl}|dkr*t|j}|||St |j|jjr|j||dzS|j||dzS)Nrr)r6rrhrrrYr]rrs r rzPythonRandomInterface.randints " " ".ty99G??1a(( ( di!4 5 5 09%%aQ// /y  AE***r!c<|jd|z S)Nr)rh exponential)rkscales r expovariatez!PythonRandomInterface.expovariatesy$$QY///r!c6|j|Sr|)rhpareto)rkshapes r paretovariatez#PythonRandomInterface.paretovariatesy&&&r!r|)rrrrrmrYrrrrrrrrrrr!r rrgs    """000 ' ' ' '+++&&& EEE + + +000'''''r!rc| |tur tjSt|tjr|St|trtj|S ddl}t|t tzr|St||jjrt|S||jurt|jj j St||jj r1||jj j urt|St |Sn#t$rYnwxYw|d}t|)a5Returns a random.Random instance depending on input. Parameters ---------- random_state : int or random number generator or None (default=None) - If int, return a `random.Random` instance set with seed=int. - If `random.Random` instance, return it. - If None or the `np.random` package, return the global random number generator used by `np.random`. - If an `np.random.Generator` instance, or the `np.random` package, or the global numpy random number generator, then return it. wrapped in a `PythonRandomViaNumpyBits` class. - If a `PythonRandomViaNumpyBits` instance, return it. - If a `PythonRandomInterface` instance, return it. - If a `np.random.RandomState` instance and not the global numpy default, return it wrapped in `PythonRandomInterface` for backward bit-stream matching with legacy code. Notes ----- - A diagram intending to illustrate the relationships behind our support for numpy random numbers is called `NetworkX Numpy Random Numbers `_. - More discussion about this support also appears in `gh-6869#comment `_. - Wrappers of numpy.random number generators allow them to mimic the Python random number generation algorithms. For example, Python can create arbitrarily large random ints, and the wrappers use Numpy bit-streams with CPython's random module to choose arbitrarily large random integers too. - We provide two wrapper classes: `PythonRandomViaNumpyBits` is usually what you want and is always used for `np.Generator` instances. But for users who need to recreate random numbers produced in NetworkX 3.2 or earlier, we maintain the `PythonRandomInterface` wrapper as well. We use it only used if passed a (non-default) `np.RandomState` instance pre-initialized from a seed. Otherwise the newer wrapper is used. Nrz4 cannot be used to generate a random.Random instance)rY_instrRandomr$r6rrr]rZr[r\rdr%r^s r rrs\J|v55|, ..,$$+}\***7 l$9>> G1 = nx.complete_graph(3) >>> G2 = nx.cycle_graph(3) >>> edges_equal(G1.edges, G2.edges) True Edge order is not taken into account: >>> G1 = nx.Graph([(0, 1), (1, 2)]) >>> G2 = nx.Graph([(1, 2), (0, 1)]) >>> edges_equal(G1.edges, G2.edges) True The `directed` parameter controls whether edges are treated as coming from directed graphs. >>> DG1 = nx.DiGraph([(0, 1)]) >>> DG2 = nx.DiGraph([(1, 0)]) >>> edges_equal(DG1.edges, DG2.edges, directed=False) # Not recommended. True >>> edges_equal(DG1.edges, DG2.edges, directed=True) False This function is meant to be used on edgelists (i.e. the output of a ``G.edges()`` call), and can give unexpected results on unprocessed lists of edges: >>> l1 = [(0, 1)] >>> l2 = [(0, 1), (1, 0)] >>> edges_equal(l1, l2) # Not recommended. False >>> G1 = nx.Graph(l1) >>> G2 = nx.Graph(l2) >>> edges_equal(G1.edges, G2.edges) True >>> DG1 = nx.DiGraph(l1) >>> DG2 = nx.DiGraph(l2) >>> edges_equal(DG1.edges, DG2.edges, directed=True) False N) fillvalueFc3K|]G}|D]<}||||kV=HdSr|)count).0edatarrs r zedges_equal..lsZTT!bQReTTdr!u{{4  BqEKK$5$55TTTTTTTr!)rr#r rall) edges1edges2re1e2rr3urDrrrs @@r rrsB T  B T  Bff===%%B :55"XBx( % %DAqKAq4 adGNN4  %!Q$t$$$  % TTTTTrTTT T TTr!cb|j|jko|j|jko|j|jkS)aCheck if graphs are equal. Equality here means equal as Python objects (not isomorphism). Node, edge and graph data must match. Parameters ---------- graph1, graph2 : graph Returns ------- bool True if graphs are equal, False otherwise. )adjnodesgraph)graph1graph2s r rros7  fj  ) LFL ( ) LFL (r!cXt|ddx}r|dSdS)zClear the cache of a graph (currently stores converted graphs). Caching is controlled via ``nx.config.cache_converted_graphs`` configuration. __networkx_cache__N)getattrclear)Gcaches r rrs9 /666u r!)r multigraphdefaultc| tj}||n|}t|tr|dn|}t|tr|dn|}|0|r|stjd|s|rtjd|0|r|stjd|s|rtjd|S)a!Assert that create_using has good properties This checks for desired directedness and multi-edge properties. It returns `create_using` unless that is `None` when it returns the optionally specified default value. Parameters ---------- create_using : None, graph class or instance The input value of create_using for a function. directed : None or bool Whether to check `create_using.is_directed() == directed`. If None, do not assert directedness. multigraph : None or bool Whether to check `create_using.is_multigraph() == multigraph`. If None, do not assert multi-edge property. default : None or graph class The graph class to return if create_using is None. Returns ------- create_using : graph class or instance The provided graph class or instance, or if None, the `default` value. Raises ------ NetworkXError When `create_using` doesn't match the properties specified by `directed` or `multigraph` parameters. Nzcreate_using must be directedz!create_using must not be directedz"create_using must be a multi-graphz&create_using must not be a multi-graph)r&Graphrtype is_directed is_multigraphr') create_usingrrrr G_directed G_multigraphs r check_create_usingrs>($0 gA(21d(;(;Pt$$$J,6q$,?,?V1??4(((Q__EVEVL  DJ D"#BCC C HJ H"#FGG G  Il I"#GHH H Ml M"#KLL L Hr!r|)F)"rrPrYre collectionsrcollections.abcrrrrrr networkxr&__all__r r r r/r2r rrrrrrrrrrrrrr!r rsC   ######5555555555----------   .    !!!H1111    .     B B B J & & & &F,<6X6X6X6X6Xv}6X6X6XtL'L'L'L'L'L'L'L't????D6-2NUNUNUNUNUb,26$PT1 1 1 1 1 1 1 r!