o pf&@sdZddlmZmZmZddlZddlZddlZddlZddl m Z ddl m Z ddl m Z mZdd lmZejrSdd lmZmZmZmZmZmZmZmZdd l mZGd d d eZeddZdS)zB`Registry` class mapping protocols and FS URLs to their `Opener`. )absolute_importprint_functionunicode_literalsN)ResourceReadOnly)Opener)EntryPointErrorUnsupportedProtocol) parse_fs_url)CallableDictIteratorListTextTupleTypeUnionFSc@sxeZdZdZdddZddZdd Zed d Zd d Z    dddZ    dddZ e j   dddZdS)Registryz"A registry for `Opener` instances.osfsFcCs||_||_i|_dS)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)selfrrrK/home/ertert/spirit/venv/lib/python3.10/site-packages/fs/opener/registry.py__init__s  zRegistry.__init__cCs d|jS)Nz)format protocols)rrrr__repr__+s zRegistry.__repr__cCsNt|tr|n|}t|tsJd|jsJd|jD]}||j|<q|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) isinstancerr r)ropener_openerprotocolrrrinstall/s   zRegistry.installcCs>t|j}|jr|ddtdDttj|}|S)z(`list`: the list of supported protocols.css|]}|jVqdS)N)name).0 entry_pointrrr Ms  z%Registry.protocols.. fs.opener) listrrextend pkg_resourcesiter_entry_points collections OrderedDictfromkeys)rrrrrr Gs  zRegistry.protocolsc Cs|p|j}|jrttd|d}nd}|dur+||jvr$|j|}|Std|z|}Wnt yD}zt d|d}~wwt |t sNt dz|}W|St yg}zt d|d}~ww)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. r+Nzprotocol '{}' is not supportedzcould not load entry point; {}z$entry point did not return an openerz could not instantiate opener; {}) rrnextr.r/rr rload Exceptionr issubclassr)rr%r)opener_instancer# exceptionrrr get_openerTs@      zRegistry.get_openerT.c CsLd|vr d||}t|}|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{}://{})rr r%pathr9open_fs) rfs_url writeablecreatecwddefault_protocol parse_resultr% open_pathr#r<rrropens  z Registry.openc Cs:ddlm}t||r|}|S|j|||||d\}}|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)r>r?r@rA)baserr"rD) rr=r>r?r@rAr_fs_pathrrrr<s #   zRegistry.open_fsccstddlm}dd}t||r|r|||VdS|j||||d}|r*||z |VW|dS|w)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) rrcSs|ddr tdddS)N read_onlyT/)r;)getmetagetr)fsrrrassert_writeables z,Registry.manage_fs..assert_writeable)r?r>r@N)rErr"r<close)rr=r?r>r@rrMrFrrr manage_fss -  zRegistry.manage_fsN)rF)TFr:r)FFr:r)FFr:)__name__ __module__ __qualname____doc__rr!r&propertyr r9rDr< contextlibcontextmanagerrOrrrrrs.   < * 1rT)r)rS __future__rrrtypingr0rUr.errorsrrErr r parser TYPE_CHECKINGr r rrrrrrrobjectrregistryrrrrs"   (