ob&dZddlmZmZmZddlZddlZddlZddlZddl m Z ddl m Z ddl m Z mZdd lmZej"rdd lmZmZmZmZmZmZmZmZdd l mZGd d eZedZy)zB`Registry` class mapping protocols and FS URLs to their `Opener`. )absolute_importprint_functionunicode_literalsN)ResourceReadOnly)Opener)EntryPointErrorUnsupportedProtocol) parse_fs_url)CallableDictIteratorListTextTupleTypeUnionFSceZdZdZd dZdZdZedZdZ d dZ d dZ e j dd Zy )Registryz"A registry for `Opener` instances.c.||_||_i|_y)aCreate a registry object. Arguments: default_opener (str, optional): The protocol to use, if one is not supplied. The default is to use 'osfs', so that the FS URL is treated as a system path if no protocol is given. load_extern (bool, optional): Set to `True` to load openers from PyFilesystem2 extensions. Defaults to `False`. N)default_opener load_extern _protocols)selfrrs 4/usr/lib/python3/dist-packages/fs/opener/registry.py__init__zRegistry.__init__s-&c8dj|jS)Nz)format protocols)rs r__repr__zRegistry.__repr__+s#**4>>::r ct|tr|n|}t|tsJd|jsJd|jD]}||j|<|S)aInstall an opener. Arguments: opener (`Opener`): an `Opener` instance, or a callable that returns an opener instance. Note: May be used as a class decorator. For example:: registry = Registry() @registry.install class ArchiveOpener(Opener): protocols = ['zip', 'tar'] zOpener instance requiredzmust list one or more protocols) isinstancer r#r)ropener_openerprotocols rinstallzRegistry.install/si"'vv6&FH'6*F,FF*  C"CC )) 0H(/DOOH % 0r ct|j}|jrS|jdt j dDtt jj|}|S)z(`list`: the list of supported protocols.c34K|]}|jyw)N)name).0 entry_points r z%Registry.protocols..Ms  s fs.opener) listrrextend pkg_resourcesiter_entry_points collections OrderedDictfromkeys)rrs rr#zRegistry.protocolsGsd$//*      #0#B#B;#O k55>>zJKJr c|xs |j}|jr!ttjd|d}nd}|9||j vr|j |}|St dj| |j}t|ts td |}|S#t$r}tdj|d}~wwxYw#t$r}tdj|d}~wwxYw)aGet the opener class associated to a given protocol. Arguments: protocol (str): A filesystem protocol. Returns: Opener: an opener instance. Raises: ~fs.opener.errors.UnsupportedProtocol: If no opener could be found for the given protocol. EntryPointLoadingError: If the returned entry point is not an `Opener` subclass or could not be loaded successfully. r1Nzprotocol '{}' is not supportedzcould not load entry point; {}z$entry point did not return an openerz could not instantiate opener; {}) rrnextr4r5rr r"load Exceptionr issubclassr )rr)r/opener_instancer' exceptions r get_openerzRegistry.get_openerTs$2t22   // XFKK  4??*"&//(";0-*4;;HE  $))+ ff-%&LMM "((  %4;;IF  %6==iH s0<B1(C1 C:CC D%C??Dcd|vrdj||}t|}|j}|j}|j |} | j |||||} | |fS)aXOpen a filesystem from a FS URL. Returns a tuple of a filesystem object and a path. If there is no path in the FS URL, the path value will be `None`. Arguments: fs_url (str): A filesystem URL. writeable (bool, optional): `True` if the filesystem must be writeable. create (bool, optional): `True` if the filesystem should be created if it does not exist. cwd (str): The current working directory. Returns: (FS, str): a tuple of ``(, )`` z://z{}://{})r"r r)pathr@open_fs) rfs_url writeablecreatecwddefault_protocol parse_resultr) open_pathr'rCs ropenz Registry.opensn4  %%&6?F#F+ (( %% *..y&#N !!r cdddlm}t||r|}|S|j|||||\}}|S)azOpen a filesystem from a FS URL (ignoring the path component). Arguments: fs_url (str): A filesystem URL. If a filesystem instance is given instead, it will be returned transparently. writeable (bool, optional): `True` if the filesystem must be writeable. create (bool, optional): `True` if the filesystem should be created if it does not exist. cwd (str): The current working directory (generally only relevant for OS filesystems). default_protocol (str): The protocol to use if one is not supplied in the FS URL (defaults to ``"osfs"``). Returns: ~fs.base.FS: A filesystem instance. Caution: The ``writeable`` parameter only controls whether the filesystem *needs* to be writable, which is relevant for some archive filesystems. Passing ``writeable=False`` will **not** make the return filesystem read-only. For this, consider using `fs.wrap.read_only` to wrap the returned instance. rr)rErFrGrH)baserr&rK) rrDrErFrGrHr_fs_paths rrCzRegistry.open_fssMF  fb !C #!1 #JC r c#Kddlm}d}t||r|r|||y|j||||}|r|| ||j y#|j wxYww)a*Get a context manager to open and close a filesystem. Arguments: fs_url (FS or str): A filesystem instance or a FS URL. create (bool, optional): If `True`, then create the filesystem if it doesn't already exist. writeable (bool, optional): If `True`, then the filesystem must be writeable. cwd (str): The current working directory, if opening a `~fs.osfs.OSFS`. Sometimes it is convenient to be able to pass either a FS object *or* an FS URL to a function. This context manager handles the required logic for that. Example: The `~Registry.manage_fs` method can be used to define a small utility function:: >>> def print_ls(list_fs): ... '''List a directory.''' ... with manage_fs(list_fs) as fs: ... print(' '.join(fs.listdir())) This function may be used in two ways. You may either pass a ``str``, as follows:: >>> print_list('zip://projects.zip') Or, an filesystem instance:: >>> from fs.osfs import OSFS >>> projects_fs = OSFS('~/') >>> print_list(projects_fs) rrc\|jjddr tdy)N read_onlyT/)rB)getmetagetr)fss rassert_writeablez,Registry.manage_fs..assert_writeables(zz| T2&C003r )rFrErGN)rMrr&rCclose)rrDrFrErGrrWrNs r manage_fszRegistry.manage_fssjZ  1 fb ! (L,,vf s,SC %    sAA1A A1A..A1N)osfsF)TF.rZ)FFr[rZ)FFr[)__name__ __module__ __qualname____doc__rr$r*propertyr#r@rKrC contextlibcontextmanagerrYr rrrs{, ;0  7x  %"T  /b  ==r rT)r)r_ __future__rrrtypingr6rar4errorsrrMr r r parser TYPE_CHECKINGr rrrrrrrrobjectrregistryrcr rrks[IH %8 OOOKvK\  %r