iGd(d)e=Z?d*Z@d+ZAid,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQZBdReBCDZDidSd9dTd9dUd9dVd9dWd9dXd9dYd9dZd9d[d1d\d1d]d3d^d3d_d=d`d=dadIdbd/dcd/ddd/iZEiZFeFGeBeFGeEdeZHe j:dfe jIe jJzZKdgZLdhZMGdidjZNddkZOddlZPdmZQdnZRGdodpeSZTdqZUeVfdrZWdsZXeXdtduZYdvZZdwZ[dxZ\Gdydze=Z]d{Z^d|Z_d}Z`d~ZadZbdecdedfdZedecfdZfdS)a~ Helper functions --- :mod:`MDAnalysis.lib.util` ==================================================== Small helper functions that don't fit anywhere else. .. versionchanged:: 0.11.0 Moved mathematical functions into lib.mdamath .. versionchanged::2.0.0 The following aliases, that existed for compatibility with python versions older than 3.6, were removed: `callable` for the built-in of the same name, `PathLike` for :class:`os.PathLike`, and `bz_open` for :func:`bz2.open`. Files and directories --------------------- .. autofunction:: filename .. autofunction:: openany .. autofunction:: anyopen .. autofunction:: greedy_splitext .. autofunction:: which .. autofunction:: realpath .. autofunction:: get_ext .. autofunction:: check_compressed_format .. autofunction:: format_from_filename_extension .. autofunction:: guess_format Modules and packages -------------------- .. autofunction:: is_installed Streams ------- Many of the readers are not restricted to just reading files. They can also use gzip-compressed or bzip2-compressed files (through the internal use of :func:`openany`). It is also possible to provide more general streams as inputs, such as a :class:`io.StringIO` instances (essentially, a memory buffer) by wrapping these instances into a :class:`NamedStream`. This :class:`NamedStream` can then be used in place of an ordinary file name (typically, with a class:`~MDAnalysis.core.universe.Universe` but it is also possible to *write* to such a stream using :func:`MDAnalysis.Writer`). .. rubric: Examples In the following example, we use a PDB stored as a string ``pdb_s``:: import MDAnalysis from MDAnalysis.lib.util import NamedStream from io import StringIO pdb_s = "TITLE Lonely Ion\\nATOM 1 NA NA+ 1 81.260 64.982 10.926 1.00 0.00\\n" u = MDAnalysis.Universe(NamedStream(StringIO(pdb_s), "ion.pdb")) print(u) # print(u.atoms.positions) # [[ 81.26000214 64.98200226 10.92599964]] It is important to provide a proper pseudo file name with the correct extension (".pdb") to :class:`NamedStream` because the file type recognition uses the extension of the file name to determine the file format or alternatively provide the ``format="pdb"`` keyword argument to the :class:`~MDAnalysis.core.universe.Universe`. The use of streams becomes more interesting when MDAnalysis is used as glue between different analysis packages and when one can arrange things so that intermediate frames (typically in the PDB format) are not written to disk but remain in memory via e.g. :class:`io.StringIO` buffers. .. The following does *not* work because most readers need to .. reopen files, which is not possible with http streams. Might .. need to implement a buffer. .. .. Read a test LAMMPS data file from the MDAnalysis repository:: .. .. import MDAnalysis .. from MDAnalysis.lib.util import NamedStream .. import urllib2 .. URI = "https://mdanalysis.googlecode.com/git-history/develop/testsuite/MDAnalysisTests/data/mini.data" .. urldata = NamedStream(urllib2.urlopen(URI), "mini.data") .. u = MDAnalysis.Universe(urldata) .. Note:: A remote connection created by :func:`urllib2.urlopen` is not seekable and therefore will often not work as an input. But try it... .. autoclass:: NamedStream :members: .. autofunction:: isstream Containers and lists -------------------- .. autofunction:: iterable .. autofunction:: asiterable .. autofunction:: hasmethod .. autoclass:: Namespace Arrays ------ .. autofunction:: unique_int_1d(values) .. autofunction:: unique_rows .. autofunction:: blocks_of .. autofunction:: group_same_or_consecutive_integers File parsing ------------ .. autoclass:: FORTRANReader :members: .. autodata:: FORTRAN_format_regex Data manipulation and handling ------------------------------ .. autofunction:: fixedwidth_bins .. autofunction:: get_weights .. autofunction:: ltruncate_int .. autofunction:: flatten_dict Strings ------- .. autofunction:: convert_aa_code .. autofunction:: parse_residue .. autofunction:: conv_float .. autofunction:: atoi Class decorators ---------------- .. autofunction:: cached .. autofunction:: store_init_arguments Function decorators ------------------- .. autofunction:: static_variables .. autofunction:: warn_if_not_unique .. autofunction:: check_coords .. autofunction:: check_atomgroup_not_empty Code management --------------- .. autofunction:: deprecate .. autoclass:: _Deprecate .. autofunction:: dedent_docstring Data format checks ------------------ .. autofunction:: check_box .. Rubric:: Footnotes .. [#NamedStreamClose] The reason why :meth:`NamedStream.close` does not close a stream by default (but just rewinds it to the beginning) is so that one can use the class :class:`NamedStream` as a drop-in replacement for file names, which are often re-opened (e.g. when the same file is used as a topology and coordinate file or when repeatedly iterating through a trajectory in some implementations). The ``close=True`` keyword can be supplied in order to make :meth:`NamedStream.close` actually close the underlying stream and ``NamedStream.close(force=True)`` will also close it. Nzrestructuredtext en)contextmanagerwraps) assert_equal)DuplicateWarning StreamWarning)bz2_pickle_opengzip_pickle_open pickle_open) unique_int_1dz\MDAnalysis not installed properly. This can happen if your C extensions have not been built.c|dd|ddk} |do|dkS#t$rYdSwxYw)Nr rT)argmin IndexError)arraymasks ]/srv/www/vhosts/g4struct/public_html/venv/lib/python3.11/site-packages/MDAnalysis/lib/util.pyint_array_is_sortedrs_ ":qrr "DAw-4;;==A-- tts8 AAchtj|d\}}|tj|S)NT return_index)npuniquesort)rvaluesindicess runique_int_1d_unsortedrs/iD999OFG !! ""Fc||}|tjjstjj|z}tj|\}}|rt |dkr||z}t|r||_n|}t|r|nt|S)a^Return a new name that has suffix attached; replaces other extensions. Parameters ---------- name : str or NamedStream filename; extension is replaced unless ``keep=True``; `name` can also be a :class:`NamedStream` (and its :attr:`NamedStream.name` will be changed accordingly) ext : None or str extension to use in the new filename keep : bool - ``False``: replace existing extension with `ext`; - ``True``: keep old extension if one existed .. versionchanged:: 0.9.0 Also permits :class:`NamedStream` to pass through. Nr) lower startswithospathextsepsplitextlenisstreamnamestr)r*extkeeprootorigextnewnames rfilenamer1s& iikk~~bgn-- ''.3&C((.. g s7||q((SjG~~ # D>> 044s4yy0r rtTc#Kt|||} |V|dS#|wxYw)aContext manager for :func:`anyopen`. Open the `datasource` and close it when the context of the :keyword:`with` statement exits. `datasource` can be a filename or a stream (see :func:`isstream`). A stream is reset to its start if possible (via :meth:`~io.IOBase.seek` or :meth:`~cString.StringIO.reset`). The advantage of this function is that very different input sources ("streams") can be used for a "file", ranging from files on disk (including compressed files) to open file objects to sockets and strings---as long as they have a file-like interface. Parameters ---------- datasource : a file or a stream mode : {'r', 'w'} (optional) open in r(ead) or w(rite) mode reset : bool (optional) try to read (`mode` 'r') the stream from the start [``True``] Examples -------- Open a gzipped file and process it line by line:: with openany("input.pdb.gz") as pdb: for line in pdb: if line.startswith('ATOM'): print(line) Open a URL and read it:: import urllib2 with openany(urllib2.urlopen("https://www.mdanalysis.org/")) as html: print(html.read()) See Also -------- :func:`anyopen` )moderesetN)anyopenclose) datasourcer4r5streams ropenanyr:sNXZd% 8 8 8F   s 0Ac tttd}tjt jtd}|dr2t|r|} t|j }n#t$rd}YnwxYw|r | n #ttf$r` | dnE#ttf$r1tjd|t"YnwxYwYnwxYwnd}|}dD] }||}t%|||}|n!|?tt&jd jdit+t-|n+|d s|d rt|r*|} t|j }n#t$rd}YnwxYwd}|}t.j|\} }|d r |d d}|dvrd}||}|||}|?tt&jd jdit+t-|n&t5djdit+ ||_ n#tt6f$rYnwxYw|S)aOpen datasource (gzipped, bzipped, uncompressed) and return a stream. `datasource` can be a filename or a stream (see :func:`isstream`). By default, a stream is reset to its start if possible (via :meth:`~io.IOBase.seek` or :meth:`~cString.StringIO.reset`). If possible, the attribute ``stream.name`` is set to the filename or "" if no filename could be associated with the *datasource*. Parameters ---------- datasource a file (from :class:`file` or :func:`open`) or a stream (e.g. from :func:`urllib2.urlopen` or :class:`io.StringIO`) mode: {'r', 'w', 'a'} (optional) Open in r(ead), w(rite) or a(ppend) mode. This string is directly passed to the file opening handler (either Python's openfe, bz2, or gzip). More complex modes are supported if the file opening handler supports it. reset: bool (optional) try to read (`mode` 'r') the stream from the start Returns ------- file-like object See Also -------- :func:`openany` to be used with the :keyword:`with` statement. .. versionchanged:: 0.9.0 Only returns the ``stream`` and tries to set ``stream.name = filename`` instead of the previous behavior to return a tuple ``(stream, filename)``. .. versionchanged:: 2.0.0 New read handlers support pickle functionality if `datasource` is a filename. They return a custom picklable file stream in :class:`MDAnalysis.lib.picklable_file_io`. )bz2gzrzrz2Stream {0}: not guaranteed to be at the beginning.categoryNr4z,Cannot open file or stream in mode={mode!r}.wa.r r<r=r>z:Sorry, mode={mode!r} is not implemented for {datasource!r})r r r r<opengzipr#r)r+r*AttributeErrorr5IOErrorseekwarningswarnformatr _get_streamerrnoEIOvarsreprr$r%r'NotImplementedError TypeError) r8r4r5 read_handlerswrite_handlersr9r1r,openfuncr*s rr6r6MsZ M !XTYDAAN sC J  ! F &v{++! & & &% &  LLNNNN&0 A*G4 %vh//%2 F!H(  (-$ZEEE%E&~IIBI&&NN       ""   J   F &v{++! & & &% &F!H((22ID#~~c"" !""g-''%c*HXjt444F~IIBI&&NN " O H O  &&       I &     MslA22 BBBD/CD?DDDD D9G GG)J11KKr?c |||}nR#ttf$r>}tj|jdvrt jd|Yd}~dSd}~wwxYw|drr |||||}n;#t$r|d}Yn|xYw|S)zTReturn open stream if *filename* can be opened with *openfunction* or else ``None``.rB)ENOENTEACCESr Nr?) rKOSErrorrQ errorcodesysexc_infor#readliner7)r1 openfunctionr4r9errs rrPrPshT222 W  ?39 %)= = =,..# ,ttttt  s 7 7 OO    LLNNN!\(666FF    LLNNNFFF  LLNNN  Ms& A3AA8B.. C&C&ctj|\}}d} tj|\}}||z}|sn+tj|||fS)aSplit extension in path *p* at the left-most separator. Extensions are taken to be separated from the filename with the separator :data:`os.extsep` (as used by :func:`os.path.splitext`). Arguments --------- p : str path Returns ------- (root, extension) : tuple where ``root`` is the full path and filename with all extensions removed whereas ``extension`` is the string of all extensions. Example ------- >>> from MDAnalysis.lib.util import greedy_splitext >>> greedy_splitext("/home/joe/protein.pdb.bz2") ('/home/joe/protein', '.pdb.bz2') r>)r$r%splitr'join)pr%r. extensionr,s rgreedy_splitextrist4q!!JD$IG$$T** c)O     7<<d # #Y ..r c\t||ott||S)z8Return ``True`` if object *obj* contains the method *m*.)hasattrcallablegetattr)objms r hasmethodrp s% 3?? 8xQ888r cd}d}|D]}t|sdSfd|D}tj|S)aDetect if `obj` is a stream. We consider anything a stream that has the methods - ``close()`` and either set of the following - ``read()``, ``readline()``, ``readlines()`` - ``write()``, ``writeline()``, ``writelines()`` Parameters ---------- obj : stream or str Returns ------- bool ``True`` if `obj` is a stream, ``False`` otherwise See Also -------- :mod:`io` .. versionadded:: 0.9.0 r7))readra readlines)write writeline writelinesFcPg|]"}tjfd|D#S)c0g|]}t|SrG)rp).0rorns r z'isstream...7s#888a #q!!888r )rall)rz alternativesrns rr{zisstream..6sH  8888<88899r )rprany)rnsignature_methodsalternative_methodsroalternative_resultss` rr)r)s~8# a   55 / 6% & &&r cd}tj|td}tj|\}}|rt |}||r|SnatjdtjD]1}tj ||}||r|cS2dS)aDetermine full path of executable `program` on :envvar:`PATH`. (Jay at http://stackoverflow.com/questions/377017/test-if-executable-exists-in-python) Parameters ---------- programe : str name of the executable Returns ------- path : str or None absolute path to the executable if it can be found, else ``None`` .. deprecated:: 2.7.0 This method is deprecated and will be removed in version 3.0.0. Please use shutil.which instead. zThis method is deprecated as of MDAnalysis version 2.7.0 and will be removed in version 3.0.0. Please use shutil.which instead.c~tj|otj|tjSN)r$r%isfileaccessX_OK)fpaths ris_exezwhich..is_exeYs)w~~e$$B5"')B)BBr PATHN) rMrNDeprecationWarningr$r%rerealpathenvironpathseprf)programwmsgrrfname real_programr%exe_files rwhichr=s,   M$*+++CCC7==))LE5  (( 6,     Jv&,,RZ88  Dw||D'22Hvh  4r c eZdZdZd#dZdZdZdZdZd Z d Z d Z d$fd Z d Z efdZejffd ZfdZfdZfdZfdZfdZfdZdZfdZdZdZdZdZdZdZ dZ!dZ"e"Z#d Z$d!Z%d"Z&xZ'S)% NamedStreama\Stream that also provides a (fake) name. By wrapping a stream `stream` in this class, it can be passed to code that uses inspection of the filename to make decisions. For instance. :func:`os.path.split` will work correctly on a :class:`NamedStream`. The class can be used as a context manager. :class:`NamedStream` is derived from :class:`io.IOBase` (to indicate that it is a stream). Many operations that normally expect a string will also work with a :class:`NamedStream`; for instance, most of the functions in :mod:`os.path` will work with the exception of :func:`os.path.expandvars` and :func:`os.path.expanduser`, which will return the :class:`NamedStream` itself instead of a string if no substitutions were made. Example ------- Wrap a :class:`io.StringIO` instance to write to:: from io import StringIO import os.path stream = StringIO() f = NamedStream(stream, "output.pdb") print(os.path.splitext(f)) Wrap a :class:`file` instance to read from:: stream = open("input.pdb") f = NamedStream(stream, stream.name) Use as a context manager (closes stream automatically when the :keyword:`with` block is left):: with NamedStream(open("input.pdb"), "input.pdb") as f: # use f print f.closed # --> False # ... print f.closed # --> True Note ---- This class uses its own :meth:`__getitem__` method so if `stream` implements :meth:`stream.__getitem__` then that will be masked and this class should not be used. Warning ------- By default, :meth:`NamedStream.close` will **not close the stream** but instead :meth:`~NamedStream.reset` it to the beginning. [#NamedStreamClose]_ Provide the ``force=True`` keyword to :meth:`NamedStream.close` to always close the stream. TFct|tr!tjdt|j}||_||_||_|r|dSdS)aZInitialize the :class:`NamedStream` from a `stream` and give it a `name`. The constructor attempts to rewind the stream to the beginning unless the keyword `reset` is set to ``False``. If rewinding fails, a :class:`MDAnalysis.StreamWarning` is issued. Parameters ---------- stream : stream an open stream (e.g. :class:`file` or :class:`io.StringIO`) filename : str the filename that should be associated with the stream reset : bool (optional) start the stream from the beginning (either :meth:`reset` or :meth:`seek`) when the class instance is constructed close : bool (optional) close the stream when a :keyword:`with` block exits or when :meth:`close` is called; note that the default is **not to close the stream** Notes ----- By default, this stream will *not* be closed by :keyword:`with` and :meth:`close` (see there) unless the `close` keyword is set to ``True``. .. versionadded:: 0.9.0 z*Constructed NamedStream from a NamedStreamN) isinstancerrMrNRuntimeWarningr9r* close_streamr5)selfr9r1r5r7s r__init__zNamedStream.__init__srB fk * * # M)rOr9r*rs r__repr__zNamedStream.__repr__s(// TYGGGr )TFF)(__name__ __module__ __qualname____doc__rr5rrrrrrr7rpropertyrr$SEEK_SETrLrrrrrrrrarrrrrrrr__rmul__rrr __classcell__)rs@rrris55n****X    ))) !!!&&& 23333X3#%+AAAAAA:33333 < < < < < 7 7 7 7 77777777777 4 4 4 4 4 , , ,77777H---HHHHHHHr rc d|vrdStjtjtjtjj|S)zJoin all args and return the real path, rooted at ``/``. Expands '~', '~user', and environment variables such as :envvar:`$HOME`. Returns ``None`` if any of the args is ``None``. N)r$r%r expanduser expandvarsrf)rs rrrsX t||t 7   27--bglD.ABBCC  r ctj|\}}|tjr |dd}||fS)zReturn the lower-cased extension of `filename` without a leading dot. Parameters ---------- filename : str Returns ------- root : str ext : str r N)r$r%r'r#r&r")r1r.r,s rget_extrsS  **ID# ~~bi  !""g  r c|dvr; t|\}}n'#t$rd|d|d}t|dwxYw|S)afCheck if this is a supported gzipped/bzip2ed file format and return UPPERCASE format. Parameters ---------- root : str path of a file, without extension `ext` ext : str extension (currently only "bz2" and "gz" are recognized as compressed formats) Returns ------- format : str upper case format extension *if* the compression can be handled by :func:`openany` See Also -------- openany : function that is used to open and decompress formats on the fly; only compression formats implemented in :func:`openany` are recognized rFz(Cannot determine coordinate format for 'rE'N)r"r ExceptionrVupper)r.r,rs rcheck_compressed_formatrs0 yy{{m## . ID## . . .MMMsMMMFF## - . 99;;s +$Ac t|\}}n$#t$rd|d}t|dwxYwt||}|S)zGuess file format from the file extension. Parameters ---------- filename : str Returns ------- format : str Raises ------ TypeError if the file format cannot be determined z'Cannot determine file format for file 'zT'. You can set the format explicitly with 'Universe(..., format=FORMAT)'.N)rrrVr)r1r.r,rrOs rformat_from_filename_extensionrsx *H%% cc *** /h / / /  T) *%T3 / /F Ms!6ct|r9 t|j}nC#t$rd|}t |dwxYwt |st|nd}|S)aDReturn the format of `filename` The current heuristic simply looks at the filename extension and can work around compressed format extensions. Parameters ---------- filename : str or stream path to the file or a stream, in which case ``filename.name`` is looked at for a hint to the format Returns ------- format : str format specifier (upper case) Raises ------ ValueError if the heuristics are insufficient to guess a supported format .. versionadded:: 0.11.0 Moved into lib.util z>guess_format requires an explicit format specifier for stream NCHAIN)r)rr*rJ ValueErroriterabler)r1rOrs r guess_formatrs6  /3HMBBFF / / /)&)) V$$$ .  /H%%  *8 4 4 4  <<>>s & Act|ttfrdSt|drdS t |n#t t f$rYdSwxYwdS)zdReturns ``True`` if `obj` can be iterated over and is *not* a string nor a :class:`NamedStream`FnextT)rr+rrkr(rVrJrns rrrNsu#[)**usFt C ~ &uu 4sAAAc*t|s|g}|S)zReturns `obj` so that it can be iterated over. A string is *not* detected as and iterable and is wrapped into a :class:`list` with a single element. See Also -------- iterable )rrs r asiterabler]s C==e Jr zU(?P\d+?)(?P[IFEAX])(?P(?P\d+)(\.(?P\d+))?)?cDt|S)z;Convert `s` to a string and return it white-space stripped.)r+stripss rrrxs q66<<>>r c8eZdZdZeeeedZdZdZ dZ dZ dS)FixedcolumnEntryzRepresent an entry at specific fixed columns. Reads from line[start:stop] and converts according to typespecifier. )IFEAcT||_||_||_|j||_dS)a} Parameters ---------- start : int first column stop : int last column + 1 typespecifier : str 'I': int, 'F': float, 'E': float, 'A': stripped string The start/stop arguments follow standard Python convention in that they are 0-based and that the *stop* argument is not included. N)startstop typespecifier convertors convertor)rrrrs rrzFixedcolumnEntry.__init__s,  *7r c |||j|jS#t$r*|d||j|j}t|dwxYw)z;Read the entry from `line` and convert to appropriate type.z: Failed to read&convert N)rrrr)rliners rrszFixedcolumnEntry.reads />>$tzDI'=">?? ? / / /00 49,-00 V$$$ .  /s &)4Ac |j|jz S)z-Length of the field in columns (stop - start))rrrs rrzFixedcolumnEntry.__len__sy4:%%r cNd|j|j|jS)Nz#FixedcolumnEntry({0:d},{1:d},{2!r}))rOrrrrs rrzFixedcolumnEntry.__repr__s(4;; J 4#5   r N) rrrrintfloatrrrrsrrrGr rr r }sm U??J888& / / /&&&     r r c6eZdZdZdZdZdZdZdZdZ dS) FORTRANReadera8FORTRANReader provides a method to parse FORTRAN formatted lines in a file. The contents of lines in a file can be parsed according to FORTRAN format edit descriptors (see `Fortran Formats`_ for the syntax). Only simple one-character specifiers supported here: *I F E A X* (see :data:`FORTRAN_format_regex`). Strings are stripped of leading and trailing white space. .. _`Fortran Formats`: http://www.webcitation.org/5xbaWMV2x .. _`Fortran Formats (URL)`: http://www.cs.mtu.edu/~shene/COURSES/cs201/NOTES/chap05/format.html c V|d_fdjD}d}g_|D]n}|ddkrUt|dD]>}||dz}jt |||d|}?c||dz }od S) acSet up the reader with the FORTRAN format string. The string `fmt` should look like '2I10,2X,A8,2X,A8,3F20.10,2X,A8,2X,A8,F20.10'. Parameters ---------- fmt : str FORTRAN format edit descriptor for a line as described in `Fortran Formats`_ Example ------- Parsing of a standard CRD file:: atomformat = FORTRANReader('2I10,2X,A8,2X,A8,3F20.10,2X,A8,2X,A8,F20.10') for line in open('coordinates.crd'): serial,TotRes,resName,name,x,y,z,chainID,resSeq,tempFactor = atomformat.read(line) ,c:g|]}|SrG)parse_FORTRAN_format)rz descriptorrs rr{z*FORTRANReader.__init__..s4   6@D % %j 1 1   r rrOXrepeatlength totallengthN)refmtentriesrangeappendr )rr( descriptorsrdrrs` rrzFORTRANReader.__init__s(99S>>    DHH     * *A{c!!q{++!!A 1X;.DL''(akBB!EE !=)) * *r c*fd|jDS)a Parse `line` according to the format string and return list of values. Values are converted to Python types according to the format specifier. Parameters ---------- line : str Returns ------- list list of entries with appropriate types Raises ------ ValueError Any of the conversions cannot be made (e.g. space for an int) See Also -------- :meth:`FORTRANReader.number_of_matches` c:g|]}|SrG)rs)rzers rr{z&FORTRANReader.read..s#333t 333r )r))rrs `rrszFORTRANReader.reads!.4333dl3333r ctd}|jD]-} |||dz }#t$rY*wxYw|S)zDReturn how many format entries could be populated with legal values.rr )r)rsr)rrmatchesr0s rnumber_of_matcheszFORTRANReader.number_of_matchess^  A t 1     s ( 55c4t|}|a td|z}|tn'#td|xYw|}|ddkrd|d<|ddkrd|d <d D];} t ||||<#t$rd ||<Y-t$rY8wxYw|d|d z|d <|S) a0Parse the descriptor. Parameters ---------- edit_descriptor : str FORTRAN format edit descriptor Returns ------- dict dict with totallength (in chars), repeat, length, format, decimals Raises ------ ValueError The `edit_descriptor` is not recognized and cannot be parsed Note ---- Specifiers: *L ES EN T TL TR / r S SP SS BN BZ* are *not* supported, and neither are the scientific notation *Ew.dEe* forms. N1z!unrecognized FORTRAN format {0!r}r%r>r rOr$r&)r%r&decimalsrr')_FORTRAN_format_patternmatchrrrO groupdictrrV)redit_descriptorror-ks rr"z"FORTRANReader.parse_FORTRAN_format sW4 $ ) )/*?*?*A*A B B 9 +11///1119$$  7>>OO KKMM X;"  AhK X;#  AhK1  A 1Q4yy!   !    X;84-s#8A))$B  C$$D5 DDc*t|jS)zReturns number of entries.)r(r)rs rrzFORTRANReader.__len__>s4<   r c\|jjdzd|jzdzS)N(r ))rrrfr(rs rrzFORTRANReader.__repr__Bs*~&,sxx/A/AACGGr N) rrrrrrsr3r"rrrGr rrrs #*#*#*J4442   333j!!!HHHHHr rctj||kstdtj|tj}tj|tj}tj|tj}||z }tj||z tj}d||z|z z}||||z ||zdS)aReturn bins of width `delta` that cover `xmin`, `xmax` (or a larger range). The bin parameters are computed such that the bin size `delta` is guaranteed. In order to achieve this, the range `[xmin, xmax]` can be increased. Bins can be calculated for 1D data (then all parameters are simple floats) or nD data (then parameters are supplied as arrays, with each entry correpsonding to one dimension). Parameters ---------- delta : float or array_like desired spacing of the bins xmin : float or array_like lower bound (left boundary of first bin) xmax : float or array_like upper bound (right boundary of last bin) Returns ------- dict The dict contains 'Nbins', 'delta', 'min', and 'max'; these are either floats or arrays, depending on the input. Example ------- Use with :func:`numpy.histogram`:: B = fixedwidth_bins(delta, xmin, xmax) h, e = np.histogram(data, bins=B['Nbins'], range=(B['min'], B['max'])) z/Boundaries are not sane: should be xmin < xmax.dtypeg?)Nbinsdeltaminmax)rr|rasarrayfloat64ceilastypeint_) rDxminxmax_delta_xmin_xmax_lengthNdxs rfixedwidth_binsrTFsD 6$+  LJKKK ZRZ 0 0 0F Jt2: . . .E Jt2: . . .EemG & !!((11A F W$ %B 52: N NNr c`t|s/|dkr) |j}n #t$rd}t|dwxYwt|rt t j|tjdkr@td t j|tjt |t |kr=td t |t |n|td|S) aCheck that a `weights` argument is compatible with `atoms`. Parameters ---------- atoms : AtomGroup or array_like The atoms that the `weights` should be applied to. Typically this is a :class:`AtomGroup` but because only the length is compared, any sequence for which ``len(atoms)`` is defined is acceptable. weights : {"mass", None} or array_like All MDAnalysis functions or classes understand "mass" and will then use ``atoms.masses``. ``None`` indicates equal weights for all atoms. Using an ``array_like`` assigns a custom weight to each element of `atoms`. Returns ------- weights : array_like or None If "mass" was selected, ``atoms.masses`` is returned, otherwise the value of `weights` (which can be ``None``). Raises ------ TypeError If `weights` is not one of the allowed values or if "mass" is selected but ``atoms.masses`` is not available. ValueError If `weights` is not a 1D array with the same length as `atoms`, then the exception is raised. :exc:`TypeError` is also raised if ``atoms.masses`` is not defined. massz3weights='mass' selected but atoms.masses is missingNrAr z.weights must be a 1D array, not with shape {0}z>weights (length {0}) must be of same length as the atoms ({1})zPweights must be {'mass', None} or an iterable of the same size as the atomgroup.) rmassesrJrVr(rrGobjectshaperrO)atomsweightsrs r get_weightsr\ss@@ G  .F!2!2 .lGG . . .JFF## - . rz'0006 7 71 < <fRZv>>>DEE \\SZZ ' '""(&Ws5zz"B"B (   *   Ns<ALArCYSCASPDGLUrPHErGLYGHISHILEr LYSKLEULMETMASNrRPROPGLNQARGRSERSTHRTVWY)VALTRPTYRci|]\}}|| SrGrG)rzthreeones r rs+5#Cr HISAHISBHSEHSDHIDHIEHIS1HIS2ASPHASHGLUHGLHLYSHLYNARGNCYSHCYS1CYS2ct|dkrt}nt} ||S#t$rd|d}t |dwxYw)aConverts between 3-letter and 1-letter amino acid codes. Parameters ---------- x : str 1-letter or 3-letter amino acid code Returns ------- str 3-letter or 1-letter amino acid code Raises ------ ValueError No conversion can be made; the amino acid code is not defined. Note ---- Data are defined in :data:`amino_acid_codes` and :data:`inverse_aa_codes`. r zNo conversion for z7 found (1 letter -> 3 letter or 3/4 letter -> 1 letter)N)r(amino_acid_codesinverse_aa_codesrKeyErrorr)rr-rs rconvert_aa_coders~, 1vv{{  +| +++ # # # #   d* +s >!Aat (?P([ACDEFGHIKLMNPQRSTVWY]) # 1-letter amino acid | # or ([0-9A-Z][a-zA-Z][A-Z][A-Z]?) # 3-letter or 4-letter residue name ) \s* # white space allowed (?P\d+) # resid \s* (: # separator ':' \s* (?P\w+) # atom name )? # possibly one crt|}|s&tdjdit t |d}|d}t|dkrt|}n|}|d}|||fS)aProcess residue string. Parameters ---------- residue: str The *residue* must contain a 1-letter or 3-letter or 4-letter residue string, a number (the resid) and optionally an atom identifier, which must be separate from the residue with a colon (":"). White space is allowed in between. Returns ------- tuple `(3-letter aa string, resid, atomname)`; known 1-letter aa codes are converted to 3-letter codes Examples -------- - "LYS300:HZ1" --> ("LYS", 300, "HZ1") - "K300:HZ1" --> ("LYS", 300, "HZ1") - "K300" --> ("LYS", 300, None) - "4GB300:H6O" --> ("4GB", 300, "H6O") - "4GB300" --> ("4GB", 300, None) zPSelection {residue!r} is not valid (only 1/3/4 letter resnames, resid required).residaar atomrG) RESIDUEr8rrOrSrgroupr(r)residuerorresnameatomnames r parse_residuers:  gA   e ^ e  &&       ! !EggdmmG 7||q!'**wwvH UH %%r cF t|S#t$r|cYSwxYw)zConvert an object `s` to float if possible. Function to be passed into :func:`map` or a list comprehension. If the argument can be interpreted as a float it is converted, otherwise the original object is passed back. )rrr s r conv_floatrLs6Qxx s   ceZdZdS) _CacheKeyN)rrrrGr rrr\sDr rcfd}|S)a_Cache a property within a class. Requires the Class to have a cache dict :attr:`_cache` and, with `universe_validation`, a :attr:`universe` with a cache dict :attr:`_cache`. Example ------- How to add a cache for a variable to a class by using the `@cached` decorator:: class A(object): def__init__(self): self._cache = dict() @property @cached('keyname') def size(self): # This code gets run only if the lookup of keyname fails # After this code has been run once, the result is stored in # _cache with the key: 'keyname' return 10.0 @property @cached('keyname', universe_validation=True) def othersize(self): # This code gets run only if the lookup # id(self) is not in the validation set under # self.universe._cache['_valid']['keyname'] # After this code has been run once, id(self) is added to that # set. The validation set can be centrally invalidated at the # universe level (say, if a topology change invalidates specific # caches). return 20.0 .. versionadded:: 0.9.0 .. versionchanged::2.0.0 Added the `universe_validation` keyword. cBtfd}|S)Nc r|jjdt}|t j} |j|vrtn(#t$rt|_twxYw|jS#t$r7|g|Ri|x|j<}r| |j|cYSwxYw)N_valid) universe_cache setdefaultdictweakrefWeakSet _cache_keyrrJradd) rrkwargsu_cache valid_cachesretfunckeyuniverse_validations rwrapperz.cached..cached_lookup..wrappers &'"m2==hOOG$+#5#5c7?;L;L#M#ML '?,>>"*N?)''' +4++& '{3''   )-d)DT)D)D)DV)D)DD C 3&6 $$T_555  s*ABA*)B*%BB>C C r)rrrrs` r cached_lookupzcached..cached_lookups> t        0r rG)rrrs`` rcachedr`s+T8 r c vjdsjd}|rtjtjfdt|Dd\}}|jd||fStjtjfdt|D}|jd|S) aqReturn the unique rows of an array. Arguments --------- arr : numpy.ndarray Array of shape ``(n1, m)``. return_index : bool, optional If ``True``, returns indices of array that formed answer (see :func:`numpy.unique`) Returns ------- unique_rows : numpy.ndarray Array of shape ``(n2, m)`` containing only the unique rows of `arr`. r_idx : numpy.ndarray (optional) Array containing the corresponding row indices (if `return_index` is ``True``). Examples -------- Remove dupicate rows from an array: >>> import numpy as np >>> from MDAnalysis.lib.util import unique_rows >>> a = np.array([[0, 1], [1, 2], [1, 2], [0, 1], [2, 3]]) >>> b = unique_rows(a) >>> b array([[0, 1], [1, 2], [2, 3]]) See Also -------- numpy.unique OWNDATAr c<g|]}t|jfSrGr+rBrziarrs rr{zunique_rows..&$K$K$KQc!ffci%8$K$K$Kr rATrrc<g|]}t|jfSrGrrs rr{zunique_rows..rr ) flagscopyrYrrviewrBr*reshape)rrrour_idxs` r unique_rowsrs V 9Y hhjj ! A 09 HH28$K$K$K$K%(($K$K$KLLH M M   5vvci  ((Q//66 I HH28$K$K$K$K%(($K$K$KLLH M M  vvci  ((Q///r c|jdstd|jd|z}|jd|z}||ks#td|||||f}||jdz||jdzz|jd|jdf}t jj|||S)aExtract a view of ``(n, m)`` blocks along the diagonal of the array `a`. Parameters ---------- a : numpy.ndarray Input array, must be C contiguous and at least 2D. n : int Size of block in first dimension. m : int Size of block in second dimension. Returns ------- view : numpy.ndarray A view of the original array with shape ``(nblocks, n, m)``, where ``nblocks`` is the number of times the miniblocks of shape ``(n, m)`` fit in the original. Raises ------ ValueError If the supplied `n` and `m` don't divide `a` into an integer number of blocks or if `a` is not C contiguous. Examples -------- >>> import numpy as np >>> from MDAnalysis.lib.util import blocks_of >>> arr = np.arange(16).reshape(4, 4) >>> view = blocks_of(arr, 2, 2) >>> view[:] = 100 >>> arr array([[100, 100, 2, 3], [100, 100, 6, 7], [ 8, 9, 100, 100], [ 12, 13, 100, 100]]) Notes ----- `n`, `m` must divide `a` into an identical integer number of blocks. Please note that if the block size is larger than the input array, this number will be zero, resulting in an empty view! Uses strides and therefore requires that the array is C contiguous. Returns a view, so editing this modifies the original array. .. versionadded:: 0.12.0 C_CONTIGUOUSz Input array is not C contiguous.rr zHMust divide into same number of blocks in both directions. Got {} by {}) rrrYrOstridesrlib stride_tricks as_strided)rDnronblocksnblocks2 new_shape new_stridess r blocks_ofrsn 7> "=;<<<gajAoGwqzQH h   vgx((   !QI AIaL1qy|++ !  ! K 6  * *1i E EEr ctj|tjtj|dz dkddzS)aSplit an array of integers into a list of same or consecutive sequences. Parameters ---------- arr: :class:`numpy.ndarray` Returns ------- list of :class:`numpy.ndarray` Examples >>> import numpy as np >>> arr = np.array([ 2, 3, 4, 7, 8, 9, 10, 11, 15, 16]) >>> group_same_or_consecutive_integers(arr) [array([2, 3, 4]), array([ 7, 8, 9, 10, 11]), array([15, 16])] r r)rrewhereediff1d)rs r"group_same_or_consecutive_integersr4s<$ 8C"*S//A"5"9::1=A B BBr c*eZdZdZdZdZdZdZdS) Namespacez3Class to allow storing attributes in new namespace.c t||S#t$rd|d}t|dwxYwN"z " is not known in the namespace.)rrrrJrrrs rrzNamespace.__getattr__LsX 3##D#.. . 3 3 3>>>>F ((d 2 3s!>c>t|||dSr)r __setitem__)rrvalues r __setattr__zNamespace.__setattr__Ts  sE*****r c t||dS#t$rd|d}t|dwxYwr)r __delitem__rrJrs r __delattr__zNamespace.__delattr__Ws^ 3   T3 ' ' ' ' ' 3 3 3>>>>F ((d 2 3s !AcL t||n#t$rYdSwxYwdS)NFT)rAssertionError)rothers rrzNamespace.__eq__^sA  u % % % %   55 ts  !!N)rrrrrrrrrGr rrrIsV==333+++333r rcLtt|| dS)aTruncate an integer, retaining least significant digits Parameters ---------- value : int value to truncate ndigits : int number of digits to keep Returns ------- truncated : int only the `ndigits` least significant digits from `value` Examples -------- >>> from MDAnalysis.lib.util import ltruncate_int >>> ltruncate_int(123, 2) 23 >>> ltruncate_int(1234, 5) 1234 N)rr+)rndigitss r ltruncate_intrgs#. s5zz7())$ % %%r cdg}|D]\}}t|tkr||fz}n||z}t|tr6|t ||t|||ft |S)a0Flatten a nested dict `d` into a shallow dict with tuples as keys. Parameters ---------- d : dict Returns ------- dict Note ----- Based on https://stackoverflow.com/a/6027615/ by user https://stackoverflow.com/users/1897/imran .. versionadded:: 0.18.0 )itemstypetuplerrextend flatten_dictr+)r- parent_keyrr;vnew_keys rrrs& E ''1 77e   A4'GG 1nG a   ' LLa117799 : : : : LL'1 & & & & ;;r c fd}|S)aDecorator equipping functions or methods with static variables. Static variables are declared and initialized by supplying keyword arguments and initial values to the decorator. Example ------- >>> from MDAnalysis.lib.util import static_variables >>> @static_variables(msg='foo calls', calls=0) ... def foo(): ... foo.calls += 1 ... print("{}: {}".format(foo.msg, foo.calls)) ... >>> foo() foo calls: 1 >>> foo() foo calls: 2 .. note:: Based on https://stackoverflow.com/a/279586 by `Claudiu `_ .. versionadded:: 0.19.0 c@D]}t||||Sr)setattr)rkwargrs rstatic_decoratorz*static_variables..static_decorators0 0 0E D% / / / / r rG)rrs` rstatic_variablesrs$6 r )warnedc<tfd}|S)aqDecorator triggering a :class:`~MDAnalysis.exceptions.DuplicateWarning` if the underlying group is not unique. Assures that during execution of the decorated method only the first of potentially multiple warnings concerning the uniqueness of groups is shown. Raises ------ :class:`~MDAnalysis.exceptions.DuplicateWarning` If the :class:`~MDAnalysis.core.groups.AtomGroup`, :class:`~MDAnalysis.core.groups.ResidueGroup`, or :class:`~MDAnalysis.core.groups.SegmentGroup` of which the decorated method is a member contains duplicates. .. versionadded:: 0.19.0 c|js tjr  |g|Ri|Sd|jj jf}t jjj }g}|D]9\}} ||ur(| d |3#Y7xYw|s d |jj}n>t|dkr |d}n"dt|}t|} d ||| } t!j| t$d d t_  |g|Ri|} d t_n#d t_wxYw| S) NrEz'{}'z 'unnamed {}'r rz a.k.a. z9{}(): {} {} contains duplicates. Results might be biased!r)messagerA stacklevelTF)isuniquewarn_if_not_uniquerrfrrinspect currentframef_backf_localsrr+rOr(sortedrTrMrNr) rrr method_name caller_locals group_namesr*rn group_name group_reprmsgresult groupmethods rrz#warn_if_not_unique..wrappers > 7/6 7;u6t666v66 6hh _ %{'; <   ,..5>DDFF  &  ID# %<<&&v}}T':':;;;  >'..u/GHHJJ    " "$QJJ# )<)<==J%[[  vk:z::   c,<KKKK$(! . [888888F(-  % %  % - - - - s,B--B1# E<<F rrrs` rrrs9( ;#####J Nr c |dd|dd|dd|dd|dd |dtdk|d d std  fd }|S) aDecorator for automated coordinate array checking. This decorator is intended for use especially in :mod:`MDAnalysis.lib.distances`. It takes an arbitrary number of positional arguments which must correspond to names of positional arguments of the decorated function. It then checks if the corresponding values are valid coordinate arrays or an :class:`~MDAnalysis.core.groups.AtomGroup`. If the input is an array and all these arrays are single coordinates (i.e., their shape is ``(3,)``), the decorated function can optionally return a single coordinate (or angle) instead of an array of coordinates (or angles). This can be used to enable computations of single observables using functions originally designed to accept only 2-d coordinate arrays. If the input is an :class:`~MDAnalysis.core.groups.AtomGroup` it is converted into its corresponding position array via a call to `AtomGroup.positions`. The checks performed on each individual coordinate array are: * Check that coordinate arrays are of type :class:`numpy.ndarray`. * Check that coordinate arrays have a shape of ``(n, 3)`` (or ``(3,)`` if single coordinates are allowed; see keyword argument `allow_single`). * Automatic dtype conversion to ``numpy.float32``. * Optional replacement by a copy; see keyword argument `enforce_copy` . * If coordinate arrays aren't C-contiguous, they will be automatically replaced by a C-contiguous copy. * Optional check for equal length of all coordinate arrays; see optional keyword argument `check_lengths_match`. Parameters ---------- *coord_names : tuple Arbitrary number of strings corresponding to names of positional arguments of the decorated function. **options : dict, optional * **enforce_copy** (:class:`bool`, optional) -- Enforce working on a copy of the coordinate arrays. This is useful to ensure that the input arrays are left unchanged. Default: ``True`` * **enforce_dtype** (:class:`bool`, optional) -- Enforce a conversion to float32. Default: ``True`` * **allow_single** (:class:`bool`, optional) -- Allow the input coordinate array to be a single coordinate with shape ``(3,)``. * **convert_single** (:class:`bool`, optional) -- If ``True``, single coordinate arrays will be converted to have a shape of ``(1, 3)``. Only has an effect if `allow_single` is ``True``. Default: ``True`` * **reduce_result_if_single** (:class:`bool`, optional) -- If ``True`` and *all* input coordinates are single, a decorated function ``func`` will return ``func()[0]`` instead of ``func()``. Only has an effect if `allow_single` is ``True``. Default: ``True`` * **check_lengths_match** (:class:`bool`, optional) -- If ``True``, a :class:`ValueError` is raised if not all coordinate arrays contain the same number of coordinates. Default: ``True`` * **allow_atomgroup** (:class:`bool`, optional) -- If ``False``, a :class:`TypeError` is raised if an :class:`AtomGroup` is supplied Default: ``False`` Raises ------ ValueError If the decorator is used without positional arguments (for development purposes only). If any of the positional arguments supplied to the decorator doesn't correspond to a name of any of the decorated function's positional arguments. If any of the coordinate arrays has a wrong shape. TypeError If any of the coordinate arrays is not a :class:`numpy.ndarray` or an :class:`~MDAnalysis.core.groups.AtomGroup`. If the dtype of any of the coordinate arrays is not convertible to ``numpy.float32``. Example ------- >>> import numpy as np >>> import MDAnalysis as mda >>> from MDAnalysis.tests.datafiles import PSF, DCD >>> from MDAnalysis.lib.util import check_coords >>> @check_coords('coords1', 'coords2', allow_atomgroup=True) ... def coordsum(coords1, coords2): ... assert coords1.dtype == np.float32 ... assert coords2.flags['C_CONTIGUOUS'] ... return coords1 + coords2 ... >>> # automatic dtype conversion: >>> coordsum(np.zeros(3, dtype=np.int64), np.ones(3)) array([1., 1., 1.], dtype=float32) >>> >>> # automatic handling of non-contiguous arrays: >>> coordsum(np.zeros(3), np.ones(6)[::2]) array([1., 1., 1.], dtype=float32) >>> >>> # automatic handling of AtomGroups >>> u = mda.Universe(PSF, DCD) >>> try: ... coordsum(u.atoms, u.select_atoms("index 1 to 10")) ... except ValueError as err: ... err ValueError('coordsum(): coords1, coords2 must contain the same number of coordinates, got [3341, 10].') >>> >>> # automatic shape checking: >>> try: ... coordsum(np.zeros(3), np.ones(6)) ... except ValueError as err: ... err ValueError('coordsum(): coords2.shape must be (3,) or (n, 3), got (6,)') .. versionadded:: 0.19.0 .. versionchanged:: 2.3.0 Can now accept an :class:`AtomGroup` as input, and added option allow_atomgroup with default False to retain old behaviour enforce_copyT enforce_dtype allow_singleconvert_singlereduce_result_if_singlecheck_lengths_matchr allow_atomgroupFzEDecorator check_coords() cannot be used without positional arguments.c  jj}|jt|jjrtjnd}|j|z d D].}| vr(t d|j/ fdt    f d S)NrztIn decorator check_coords(): Name '{}' doesn't correspond to any positional argument of the decorated function {}().c d}t|tjrrT|jdvs|jddkr d|d|j}t ||jdkrd}r |dddf}n:|jd ks|jddkr d|d |j}t | rR |tjd }n.#t $r! d|d |jd}t|dwxYw|jd}n\ |j }|jd}std}|n3#t$r&t d|dt|dwxYw|||fS)NF)r rrz(): z#.shape must be (3,) or (n, 3), got r Trz.shape must be (n, 3) got r_)orderrz*.dtype must beconvertible to float32, got rErzgAtomGroup or other class with a`.positions` method supplied as anargument, but allow_atomgroup is Falsez(): Parameter 'z/' must be a numpy.ndarray or an AtomGroup, got ) rrndarrayndimrYrrJfloat32rBrV positionsrJr) coordsargname is_singlerncoordrcrrrrrrs r _check_coordszCcheck_coords..check_coords_decorator.._check_coordssTI&"*--2 1 611v|B7G17L7L$::'::+1<::)000{a''$( )5%+D!!!G_F q((fl1o.B.B$22'22#)<22)000 : :!'Jc "/""&:::$00'00 & 000 (//T9 : a#-F#\!_F*"'% " "&# 0000 $V 0009f, ,s1"C+C?'D990E)c t|krd_t|kr|i|Sdt|D]}||vr |i|cSt|dD]}||vr |i|cS|D]}| vr |i|cSd_t|}g} } D]}|}|t|kr4|||\||<}}||z}||^|||\||<}}||z}|| re|rc||dt|kr7t d d ||rr|i|dS|i|S)NTFrz={}(): {} must contain the same number of coordinates, got {}.z, ) r( _invalid_calllistindexr+countrrOrf)rrr*ncoords all_singleidxr(r)r*rargnamesr coord_namesrrnargsnposargs posargnamesrrs rrz=check_coords..check_coords_decorator..wrappers4yyH$$(,%t99u$$40000' #d)) 455Dv~~#tT4V44444&(D 455D6))#tT4V44444*#55D8++#tT4V44444,).%::DG%J# + +!''--T??3@=S 4440DIy&)+JNN6****6Cmt d773F4L)V)+JNN6****" w ==,,G <<$!6%;)?)?II  05 0tT,V,,Q//4((( (r ) r__code__ co_varnamesr( __defaults__ co_argcountrrOr)rcode ndefaultsr*r*r3rr5r6r7rrrrrr4rrrs` @@@@@@@rcheck_coords_decoratorz,check_coords..check_coords_decoratorsQ }#D$%%.2.?FC)***Q #i/yy)    D;&& vdDM22 '6 -6 -6 -6 -6 -6 -6 -6 -6 -6 -p t1 )1 )1 )1 )1 )1 )1 )1 )1 )1 )1 )1 )1 )1 )1 ) 1 )fr )getr(r) r4optionsr>rrrrrrrs ` @@@@@@@r check_coordsrAsl;;~t44LKK66M;;~t44L[[!1488N%kk*CTJJ!++s;//!3kk"3U;;O   $   @@@@@@@@@@@@D "!r c<tfd}|S)aDDecorator triggering a ``ValueError`` if the underlying group is empty. Avoids downstream errors in computing properties of empty atomgroups. Raises ------ ValueError If the input :class:`~MDAnalysis.core.groups.AtomGroup`, of a decorated method is empty. .. versionadded:: 2.4.0 cL|jstd|g|Ri|}|S)NzAtomGroup is empty.)rZr)rrrrrs rrz*check_atomgroup_not_empty..wrapper( sD{ 9233 3![888888F r rrs` rcheck_atomgroup_not_emptyrD s8 ; Nr c||_|Sr)r)rr*s r_set_function_namerF> sDM Kr c*eZdZdZ ddZdZdS) _Deprecatez Decorator class to deprecate old functions. Refer to `deprecate` for details. See Also -------- deprecate .. versionadded:: 0.19.0 Nc||_||_|tdt||_|t|n||_||_dS)Nz;deprecate: provide release in which feature was deprecated.)old_namenew_namerr+releaseremover)rrJrKrLrMrs rrz_Deprecate.__init__Q s^!   ?* 7|| %+%7c&kkkV  r c|j}|j}|j}|j}|j}| j}n#t $r j}YnwxYw|d|} nd||} | d} |d||} d| zz |d|zz fd} t| |} tj } n#t$rd} YnwxYwtd||r|n| | } d | | | } | | _ j }| j |n#t $rYnwxYw| S) z: Decorator call. Refer to ``decorate``. Nz`{0}` is deprecated!z'`{0}` is deprecated, use `{1}` instead!r>z%`{0}` will be removed in release {1}. cLtjtd|i|S)zThis function is deprecated.r)r)rMrNr)rkwdsr warn_messages rnewfuncz$_Deprecate.__call__..newfunc s0 M,(:q I I I I4&&& &r zE .. deprecated:: {0} {1} {2} z {0} {1} {2} )rJrKrrLrMrrJrOrFdedent_docstringrrV__dict__update)rrrrrJrKrrLrMdepdoc remove_textrSdocdeprecation_textr-rRs ` @r__call__z_Deprecate.__call__d s ==,,   )=! ) ) )= )  +228<EE(F   AHH&K D;. .L   D7N *L ' ' ' ' ' ' %Wh77 "4<00CC   CCC ,  FG7     "((6FGG ' A   # #A & & & &    D s31AA;C CC)E EE)NNNNN)rrrrrr[rGr rrHrHC sW   &HHHHHr rHcl|r'|d}|dd}t|i||St|i|S)aw Issues a DeprecationWarning, adds warning to `old_name`'s docstring, rebinds ``old_name.__name__`` and returns the new function object. This function may also be used as a decorator. It adds a restructured text ``.. deprecated:: release`` block with the sphinx deprecated role to the end of the docs. The `message` is added under the deprecation block and contains the `release` in which the function was deprecated. Parameters ---------- func : function The function to be deprecated. old_name : str, optional The name of the function to be deprecated. Default is None, in which case the name of `func` is used. new_name : str, optional The new name for the function. Default is None, in which case the deprecation message is that `old_name` is deprecated. If given, the deprecation message is that `old_name` is deprecated and `new_name` should be used instead. release : str Release in which the function was deprecated. This is given as a keyword argument for technical reasons but is required; a :exc:`ValueError` is raised if it is missing. remove : str, optional Release for which removal of the feature is planned. message : str, optional Additional explanation of the deprecation. Displayed in the docstring after the warning. Returns ------- old_func : function The deprecated function. Examples -------- When :func:`deprecate` is used as a function as in the following example, .. code-block:: python oldfunc = deprecate(func, release="0.19.0", remove="1.0", message="Do it yourself instead.") then ``oldfunc`` will return a value after printing :exc:`DeprecationWarning`; ``func`` is still available as it was before. When used as a decorator, ``func`` will be changed and issue the warning and contain the deprecation note in the do string. .. code-block:: python @deprecate(release="0.19.0", remove="1.0", message="Do it yourself instead.") def func(): \"\"\"Just pass\"\"\" pass The resulting doc string (``help(func)``) will look like: .. code-block:: reST `func` is deprecated! Just pass. .. deprecated:: 0.19.0 Do it yourself instead. `func` will be removed in 1.0. (It is possible but confusing to change the name of ``func`` with the decorator so it is not recommended to use the `new_func` keyword argument with the decorator.) .. versionadded:: 0.19.0 rr N)rH)rrfns r deprecater^ sSn + !WABBx*z4*6**2...4*6***r c|}t|dkr|S|ddztjd|ddzS)aODedent typical python doc string. Parameters ---------- text : str string, typically something like ``func.__doc__``. Returns ------- str string with the leading common whitespace removed from each line See Also -------- textwrap.dedent .. versionadded:: 0.19.0 rrrOr N) splitlinesr(lstriptextwrapdedentrf)textliness rrTrT sn* OO  E 5zzA~~{{}} 8??  t #hodiiabb 6J6J&K&K KKr c|tdddlm}tj|tjd}|jdkrtdtj|d dd kr d |dd fSd ||fS) aTake a box input and deduce what type of system it represents based on the shape of the array and whether all angles are 90 degrees. Parameters ---------- box : array_like The unitcell dimensions of the system, which can be orthogonal or triclinic and must be provided in the same format as returned by :attr:`MDAnalysis.coordinates.timestep.Timestep.dimensions`: ``[lx, ly, lz, alpha, beta, gamma]``. Returns ------- boxtype : {``'ortho'``, ``'tri_vecs'``} String indicating the box type (orthogonal or triclinic). checked_box : numpy.ndarray Array of dtype ``numpy.float32`` containing box information: * If `boxtype` is ``'ortho'``, `cecked_box` will have the shape ``(3,)`` containing the x-, y-, and z-dimensions of the orthogonal box. * If `boxtype` is ``'tri_vecs'``, `cecked_box` will have the shape ``(3, 3)`` containing the triclinic box vectors in a lower triangular matrix as returned by :meth:`~MDAnalysis.lib.mdamath.triclinic_vectors`. Raises ------ ValueError If `box` is not of the form ``[lx, ly, lz, alpha, beta, gamma]`` or contains data that is not convertible to ``numpy.float32``. See Also -------- MDAnalysis.lib.mdamath.triclinic_vectors .. versionchanged: 0.19.0 * Enforced correspondence of `box` with specified format. * Added automatic conversion of input to :class:`numpy.ndarray` with dtype ``numpy.float32``. * Now also returns the box in the format expected by low-level functions in :mod:`~MDAnalysis.lib.c_distances`. * Removed obsolete box types ``tri_box`` and ``tri_vecs_bad``. Nz Box is Noner )triclinic_vectorsr_)rBr!)zNInvalid box information. Must be of the form [lx, ly, lz, alpha, beta, gamma].r gV@orthotri_vecs)rmdamathrgrrGr$rYr|)boxrgs r check_boxrm/ sX {'''****** *S # 6 6 6C yD 0    vc!""go BQB ((-- --r crtjtjfd}|S)aDecorator to store arguments passed to the init method of a class. Arguments are stored as a dictionary in ``cls._kwargs``. Notes ----- * Only does a shallow copy, if the arguments are changed by the class after passing through the decorator this will be reflected in the stored arguments. * If not empty, ``args`` is not unpacked and stored as-is in the dictionary. If no ``args`` are passed, then no ``arg`` entry will be stored in the dictionary. .. versionadded:: 2.2.0 ct|ds j|g|Ri|}|i|_|jD]d\}}|dkrY|dkr%|D]\}}||j|<6|dkrt |dkr ||j|<Z||j|<e|g|Ri|S)N_kwargsrrrr)rkbindapply_defaultsrp argumentsrr() rrr arg_valuesrargr;rrsigs rrz%store_init_arguments..wrapper} stY'' 0!$888888J  % % ' ' 'DL&06688 0 0S&==h$'IIKK00DAq./DLOO0s88a<<03DL-,/ S)tD*4***6***r )r signature functoolsr)rrrvs` @rstore_init_argumentsryj sP"  D ! !C_T++++++" Nr c:tjjdkrd}nd}|S)Nz2.0.0rc1F)rr NumpyVersion)rs r no_copy_shimr| s# vj(( Kr r returnc  tdtjtj|S#t$rYdSwxYw)aConvert the leading number part of a string to an integer. Parameters ---------- s : str The string to convert to an integer. Returns ------- number : int The first numeric part of the string converted to an integer. If the string does not start with a number, 0 is returned. Examples -------- >>> from MDAnalysis.lib.util import atoi >>> atoi('34f4') 34 >>> atoi('foo') 0 .. versionadded:: 2.8.0 r>r)rrf itertools takewhiler+isdigitrrr s ratoir sZ22779.s{AGGIIFFGGHHH qqsAA A! A! modulenamecDtj|duS)zChecks if module is installed Parameters ---------- modulename : str name of the module to be tested .. versionadded:: 2.8.0 N) importlibutil find_spec)rs r is_installedr s > # #J / /t ;;r )NF)r2Tr)grr_ __docformat__r<rQrxrIrriorr$os.pathrerbrMr contextlibrrmmtfnumpyr numpy.testingr exceptionsrr picklable_file_ior r r _cutilr ImportErrorrrr1r:r6rHrPrirpr)rtotal_orderingIOBasePathLikerrrrrrrrFORTRAN_format_regexcompiler7rrXr rrTr\canonical_inverse_aa_codesrralternative_inverse_aa_codesrrVrVERBOSE IGNORECASErrrrrrrrrrrrrrrrArDrFrHr^rTrmryr|r+rrrrGr rrs9.llZ %      %%%%%% &&&&&&88888888MMMMMMMMMM%%%%%%% +   ### 1111B////d{{{{|(,#6!/!/!/H999 +'+'+'\)))X LHLHLHLHLH")R[LHLHLH^   (D:111h      *:%"*%9:: . . . . . v. . . bUHUHUHUHUHFUHUHUHp*O*O*OZ888@ 3 3 3 3   3   3  3 3 3 3 3 3 3 3 3  3!" 3#$   )0!;!A!A!C!C   C  #S */ 6;S BG  C   C   C      C       C   C  %c  23334555"+"+"+N "* J  &+&+&+&\            FFFFR:0:0:0:0zKFKFKF\CCC*<&&&4 %uww@   b99 9xG"G"G"TJ iiiiiiiiX\+\+\+FLLL:8.8.8.v%%%PCC>