o ADiv@snddlmZddlZddlZddlZddlmZmZmZddl m Z m Z m Z m Z mZddlmZmZmZmZmZddlmZddlmZmZmZddlZdd lmZed Zd*ddZdZ dZ!ej"GdddZ#ej"GdddZ$ej%GdddZ&d+ddZ'edZ(edZ)ed Z*ed!Z+ed"Z,ed#Z-ed$Z.ed%Z/ed&Z0ed'Z1ej%Gd(d)d)Z2dS),) annotationsN) AwaitableCallableIterator)AbstractAsyncContextManagerAbstractContextManagerasynccontextmanagercontextmanagersuppress)isasyncgenfunction isawaitable iscoroutineiscoroutinefunctionisgeneratorfunction) TracebackType)AnyTypeVaroverload)ServiceNotFoundErrorsvcsobjobjectreturnstrcCs0z |jd|jWStyt|YSw)N.) __module__ __qualname__AttributeErrorrepr)rr C/var/www/Datamplify/venv/lib/python3.10/site-packages/svcs/_core.py _full_name%s   r" svcs_registrysvcs_containerc@sjeZdZUdZded<ejddZded<ded <ded <ejddZd ed <e dddZ dddZ dS)RegisteredServicea A recipe for creating a service. .. warning:: Strictly read-only. Attributes: svc_type: The type under which the type has been registered. factory: Callable that creates the service. takes_container: Whether the factory takes a container as its first argument. enter: Whether context managers returned by the factory are entered. ping: See :ref:`health`. typesvc_typeF)hashrfactorybooltakes_containerenterCallable | NonepingrrcCs t|jSN)r"r'selfr r r!nameMs zRegisteredService.namec Cs2d|jd|jd|jd|jd|jdud S)Nz)r2r)r+r,r.r0r r r!__repr__QszRegisteredService.__repr__Nrr) __name__rr__doc____annotations__attrsfieldr)r.propertyr2r4r r r r!r%1s  r%c@sNeZdZUdZded<ded<ded<ded <d ed <dddZdddZdS) ServicePinga A service health check as returned by :meth:`svcs.Container.get_pings`. Attributes: name: A fully-qualified name of the service type. is_async: Whether the service needs to be pinged using :meth:`aping`. See Also: :ref:`health` rr2r*is_asyncr& _svc_typer_ping Container _containerrNonecCs|j|j}||dS)z Acquire the service, schedule its cleanup, and call its ping callable with the acquired service as its only argument. N)rAgetr>r?r1svcr r r!r.qszServicePing.pingcs>|j|jIdH}|jr||IdHdS||dS)z Same as :meth:`ping` but acquire and/or ping asynchronously, if necessary. Also works with synchronous services, so in an async application, just use this. N)rAagetr>r=r?rDr r r!apingys zServicePing.apingNrrB)r6rrr7r8r.rGr r r r!r<]s   r<c@seZdZUdZeeZded<ee Z ded<d=dd Z d>d dZ d?ddZ d@ddZdAddZd@ddZdAdd ZdBd!d"Zd#d$d$d%dCd-d.Zd/d$d$d%dDd2d3Z $dEdFd5d6ZdGd7d8ZdBd9d:ZdBd;d<Zd$S)HRegistryai A central registry of recipes for creating services. An instance of this should live as long as your application does. Also works as a context manager that runs ``on_registry_close`` callbacks on exit: .. doctest:: >>> import svcs >>> with svcs.Registry() as reg: ... reg.register_value( ... int, 42, ... on_registry_close=lambda: print("closed!") ... ) closed! ``async with`` is also supported. Warns: ResourceWarning: If a registry with pending cleanups is garbage-collected. zdict[type, RegisteredService] _servicesz&list[tuple[str, Callable | Awaitable]] _on_closerrcCsdt|jdS)Nz>> reg = svcs.Registry() >>> reg.register_value(int, 42) >>> int in reg True >>> str in reg False )rJr1r'r r r! __contains__s zRegistry.__contains__Iterator[RegisteredService]cCst|jS)zn Returns: An iterator over registered services. .. versionadded:: 25.1.0 )iterrJvaluesr0r r r!__iter__szRegistry.__iter__cC|Sr/r r0r r r! __enter__zRegistry.__enter__exc_typetype[BaseException] | Noneexc_valBaseException | Noneexc_tbTracebackType | NonerBcC |dSr/closer1rWrYr[r r r!__exit__ zRegistry.__exit__c|Sr/r r0r r r! __aenter__zRegistry.__aenter__c|IdHdSr/acloser`r r r! __aexit__zRegistry.__aexit__cC$t|ddrtjdtdddSdS)zD Warn if the registry is gc'ed before being closed. rKNz5Registry was garbage-collected with pending cleanups.r stacklevelgetattrwarningswarnResourceWarningr0r r r!__del__  zRegistry.__del__TNr,r.on_registry_closer)rr,r.r-rvCallable | Awaitable | NonecCs:|j|||||d}tjd||j|jt|ddddS)a9 Register *factory* to be used when asked for a *svc_type*. Repeated registrations overwrite previous ones, but the *on_registry_close* callbacks are run all together when the registry is closed. Args: svc_type: The type of the service to register. factory: A callable that is used to instantiated *svc_type* if asked. If it's a generator or a context manager, a cleanup is registered after instantiation. Can also be an async callable/generator/context manager. If *factory* takes a first argument called ``svcs_container`` or the first argument (of any name) is annotated as being :class:`svcs.Container`, the container instance that is instantiating the service is passed into the factory as the first positional argument. Note: Generally speaking, given the churn and edgecases in the typing ecosystem, we recommend using the name route to detect the container argument because it's most reliable. enter: Whether to enter context managers if one is returned by *factory*. Usually you want that, but there are occasions -- like database transaction managers -- that you want to enter manually. ping: A callable that marks the service as having a health check. See Also: :meth:`Container.get_pings` and :class:`ServicePing`. on_registry_close: A callable that is called when the :meth:`svcs.Registry.close()` method is called. Can also be an async callable or an :class:`collections.abc.Awaitable`; then :meth:`svcs.Registry.aclose()` must be called. .. versionchanged:: 25.1.0 *factory* now may take any amount of arguments and they are ignored. ruz)registered factory %r for service type %s)svcs_service_namesvcs_factory_nameTextra stack_infoN)_register_factorylogdebugr2r"r1r'r)r,r.rvrsr r r!register_factorys < zRegistry.register_factoryFvaluercs>|j|fdd|||d}tjd|j|jddddS) a Syntactic sugar for:: register_factory( svc_type, lambda: value, enter=enter, ping=ping, on_registry_close=on_registry_close ) Please note that, unlike with :meth:`register_factory`, entering context managers is **disabled** by default. .. versionchanged:: 23.21.0 *enter* is now ``False`` by default. cSr/r r rr r!Mz)Registry.register_value..ruz'registered value %r for service type %s)rx svcs_valueTrzN)r}r~rr2)r1r'rr,r.rvrr rr!register_value1s   zRegistry.register_valuer%cCs^t|r t|}nt|rt|}t||t|||}||j|<|dur-|j|j |f|Sr/) rr r rr%_takes_containerrJrKappendr2rr r r!r}[s  zRegistry._register_factorycCs&z|j|WStyt|dwr/)rJKeyErrorrrNr r r!get_registered_service_forps    z#Registry.get_registered_service_forc Cst|jD]=\}}t|st|rtjd|dddqztd||td|WqtyBtj d|dd |id Yqw|j |j d S) z Clear registrations and run synchronous *on_registry_close* callbacks. Async callbacks are *not* awaited and a warning is raised Errors are logged at warning level, but otherwise ignored. Skipped async cleanup for . Use aclose() instead.rrl closing %r closed %r4Registry's on_registry_close callback failed for %r.Trxexc_infor{N) reversedrKrr rprqr~r ExceptionwarningrJclearr1r2ocr r r!r_vs*     zRegistry.closec st|jD]F\}}z.t|r|}t|r(td||IdHtd|ntd||td|WqtyLtjd|dd|id Yqw|j |j dS) z Clear registrations and run all *on_registry_close* callbacks. Errors are logged at warning level, but otherwise ignored. Also works with synchronous services, so in an async application, just use this. zasync closing %rNzasync closed %rrrrTrxr) rrKrr r~rrrrJrrr r r!rhs.        zRegistry.acloser5r'r&rr*)rrP)rrIrWrXrYrZr[r\rrBrH r'r&r)rr,r*r.r-rvrwrrB r'r&rrr,r*r.r-rvrwrrBr/) r'r&r)rr,r*r.r-rvrwrr%)r'r&rr%)r6rrr7r9FactorydictrJr8listrKr4rOrSrUrardrirsrrr}rr_rhr r r r!rIs2        T0  "rIr)rr*c Csz tj|dtidd}Wnty(zt|}Wn ty%YYdSwYnwz tt|j\}}Wn ty@YdSw|dkpL|j tddfvS)zP Return True if *factory* takes a svcs.Container as its first argument. r@T)localseval_strFr$zsvcs.Container) inspect signaturer@rnextrQ parametersitems StopIteration annotation)r)sigr2pr r r!rs,     rT1T2T3T4T5T6T7T8T9T10c@s eZdZUdZded<dZded<eeZ ded<ee Z d ed <d{d dZ d|ddZ d}ddZd~ddZd}dd Zd~d!d"Zdd#d$Zdd%d&Zdd'd(Zdd*d+Zdd.d/Zdd0d1Zdd3d4Zd5ddd6dd>d?Zd@ddd6ddCdDZeddGdHZeddMdHZeddQdHZeddUdHZeddYdHZedd]dHZeddadHZeddedHZeddidHZeddmdHZddndHZeddodpZeddqdpZeddrdpZeddsdpZeddtdpZeddudpZeddvdpZeddwdpZeddxdpZeddydpZddzdpZdS)r@a A per-context container for instantiated services and cleanups. The instance of this should live as long as a request or a task. Also works as a context manager that runs clean ups on exit: .. doctest:: >>> reg = svcs.Registry() >>> def factory() -> str: ... yield "Hello World" ... print("Cleaned up!") >>> reg.register_factory(str, factory) >>> with svcs.Container(reg) as con: ... _ = con.get(str) Cleaned up! Warns: ResourceWarning: If a container with pending cleanups is garbage-collected. Attributes: registry: The :class:`Registry` instance that this container uses for service type lookup. rIregistryNzRegistry | None_lazy_local_registryzdict[type, object] _instantiatedzFlist[tuple[str, AbstractContextManager | AbstractAsyncContextManager]]rKrrcCsdt|jdt|jdS)Nzs z'Container.get_pings..)rrJrRr0r r0r! get_pingss  zContainer.get_pings svc_typesrcGs |j|S)a Like :meth:`get` but is annotated to return :data:`typing.Any` which allows it to be used with abstract types like :class:`typing.Protocol` or :mod:`abc` classes. Note: See :doc:`typing-caveats` why this is necessary. )rCr1rr r r! get_abstracts zContainer.get_abstractcs|j|IdHS)z Same as :meth:`get_abstract` but instantiates asynchronously, if necessary. Also works with synchronous services, so in an async application, just use this. N)rFrr r r! aget_abstractszContainer.aget_abstracttuple[bool, object, str, bool]cCs|j|tj}tjurd|ddfSd}|jdur4tt|j|}Wdn1s/wY|dur>|j|}|j rF| |n| }d||j |j fS)z Look up svc_type first in our cache, then in the registry. If it's cached, only the first two items of the returned tupled are meaningful. TFN) rrCr9NOTHINGrr rrrr+r)r2r,)r1r'rErr r r!_lookups    zContainer._lookupTrur)rr,r.r-rvrwcCs,|jdur t|_|jj|||||ddS)a^ Same as :meth:`svcs.Registry.register_factory()`, but registers the factory only for this container. A temporary :class:`svcs.Registry` is transparently created -- and closed together with the container it belongs to. See Also: :ref:`local-registries` .. versionadded:: 23.21.0 N)r'r)r,r.rv)rrIr)r1r'r)r,r.rvr r r!register_local_factorys  z Container.register_local_factoryFrrcs |j|fdd|||ddS)a Syntactic sugar for:: register_local_factory( svc_type, lambda: value, enter=enter, ping=ping, on_registry_close=on_registry_close ) Please note that, unlike with :meth:`register_local_factory`, entering context managers is **disabled** by default. See Also: :ref:`local-registries` .. versionadded:: 23.21.0 crr/r r rr r!rrz0Container.register_local_value..ruN)r)r1r'rr,r.rvr rr!register_local_values  zContainer.register_local_valuetype[T1]rcCdSr/r rNr r r!rCrVz Container.get svc_type1 svc_type2type[T2] tuple[T1, T2]cCrr/r r1rrr r r!rC  svc_type3type[T3]tuple[T1, T2, T3]cCrr/r r1rrrr r r!rCr svc_type4type[T4]tuple[T1, T2, T3, T4]cCrr/r r1rrrrr r r!rCs svc_type5type[T5]tuple[T1, T2, T3, T4, T5]cCrr/r r1rrrrrr r r!rCs svc_type6type[T6]tuple[T1, T2, T3, T4, T5, T6]cCrr/r r1rrrrrrr r r!rC(s svc_type7type[T7]!tuple[T1, T2, T3, T4, T5, T6, T7]cCrr/r r1rrrrrrrr r r!rC4s svc_type8type[T8]%tuple[T1, T2, T3, T4, T5, T6, T7, T8]c Crr/r r1rrrrrrrrr r r!rCAs svc_type9type[T9])tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9]c Crr/r r1rrrrrrrrrr r r!rCOs svc_type10 type[T10].tuple[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]c Crr/r r1rrrrrrrrrrr r r!rC^sc Gsg}|D]?}||\}}}}|r||qt|s t|tr&d}t||r9t|tr9|j||f|}||j |<||qt |dkrN|dS|S)aE Get services of *svc_types*. Instantiate them if necessary and register their cleanup. Returns: ``svc_types[0]`` | ``tuple[*svc_types]``: If one service is requested, it's returned directly. If multiple are requested, a tuple of services is returned. z!Use `aget()` for async factories.rr) rrr rr TypeErrorrrKrUrrL) r1rrvr'cachedrEr2r,msgr r r!rCns&      cdSr/r rNr r r!rFrezContainer.agetcrr/r rr r r!rFcrr/r rr r r!rFrcrr/r rr r r!rFscrr/r rr r r!rFs crr/r rr r r!rFs crr/r rr r r!rFs c rr/r rr r r!rFs c rr/r rr r r!rFs c rr/r rr r r!rFscsg}|D]{}||\}}}}|r||q|r/t|tr/|j||f|IdH}nG|rCt|trC|j||f|}n3t|rv|IdH}|rct|trc|j||f|IdH}n|rvt|trv|j||f|}||j |<||qt |dkr|dS|S)a Same as :meth:`get` but instantiates asynchronously, if necessary. Also works with synchronous services, so in an async application, just use this. .. versionchanged:: 25.1.0 Synchronous context managers are now entered/exited, too. Nrr) rrrrrKrdrrUr rrL)r1rrr'rrEr2r,r r r!rFs4       r5r)rr@rrH)rr)rr&rr)r'r&rrrr)r'rrr)rrrrrr)rrrrrrrr) rrrrrrrrrr) rrrrrrrrrrrr)rrrrrrrrrrrrrr)rrrrrrrrrrrrrrrr)rrrrrrrrrrrrrrrrrr)rrrrrrrrrrrrrrrrrrrr)rrrrrrrrrrrrrrrrrrrrrr)rr&rr)r6rrr7r8rr9rrrrrKr4rOrUrardrirsr_rhrrrrrrrrCrFr r r r!r@s          & !  %$           %          r@)rrrr)r)rrr*)3 __future__rrloggingrpcollections.abcrrr contextlibrrrr r r r r rrtypesrtypingrrrr9 exceptionsr getLoggerr~r" _KEY_REGISTRY_KEY_CONTAINERfrozenr%r<definerIrrrrrrrrrrrr@r r r r!sH     +* 3