o Lj?@sTdZddlZddlmZmZddlmZddlmZddl m Z m Z m Z dZ dZd Zd Zd Ze d eZe d eZe d eZe d eZd edee defddZde d edee defddZd edefddZeeZeZdefddZ e Z!eZ"dede#defddZ$ddZ%ed d!Gd"d#d#Z&Gd$d%d%Z'dS)&adHIMPORT client-side fieldset registry for redis-py. `HIMPORT` lets a client register an ordered list of hash field names once per connection (a *fieldset*) and then create many hashes by sending only values. Because a fieldset is server-side session state bound to a single physical connection, redis-py keeps a client-level registry of the fieldsets the application has declared and prepares them lazily, per connection, on first use by ``himport_set``. This module holds only that registry. It is pure in-memory state with no I/O and no ``asyncio`` primitives, so a single class is shared by both the sync and async clients. Example:: >>> from redis.himport import HImportRegistry >>> registry = HImportRegistry() >>> registry.prepare("account_data", ["name", "email", "age"]) >>> registry.get("account_data").fields ('name', 'email', 'age') N)IterableIterator) dataclass) DataError) EncodableTFieldTKeyTHIMPORTPREPARESETDISCARD DISCARDALL fieldset_namefieldsreturncCstt|g|RS)zMPositional wire args for ``HIMPORT PREPARE fieldset_name field [field ...]``.)_HIMPORT_PREPARE)rrrK/home/djax/ivt_ai_plugin/venv/lib/python3.10/site-packages/redis/himport.pyhimport_prepare_command5srkeyvaluescCstt||g|RS)zMPositional wire args for ``HIMPORT SET key fieldset_name value [value ...]``.)r_SET)rrrrrrhimport_set_command:srcCs tt|fS)z;Positional wire args for ``HIMPORT DISCARD fieldset_name``.)r_DISCARD)rrrrhimport_discard_commandAs rcCsVt|trt|tko|tkSt|tttfr)t|}t|tko(|t kSdS)abReturn ``True`` if ``command_name`` names the ``HIMPORT SET`` command. Redis command names are case-insensitive on the wire, and a caller using the raw ``execute_command`` API may pass the name in any case and as either ``str`` or ``bytes`` (e.g. ``execute_command("himport set", ...)`` or ``b"HIMPORT SET"``). The connection-state-aware ``HIMPORT SET`` path keys off the command name, so it must recognise all of those spellings: an exact comparison against :data:`HIMPORT_SET` would miss them and send a bare SET that fails with ``no such fieldset`` for a fieldset registered in the client but not yet PREPAREd on the borrowed connection. The length check keeps the per-command cost on the hot path to a single comparison for the common case of a differently-sized command name (``upper()`` runs only on a size match). F) isinstancestrlen_HIMPORT_SET_LENupper HIMPORT_SETbytes bytearray memoryview_HIMPORT_SET_BYTES) command_namerawrrris_himport_set_commandJs   r) upper_tokenupper_token_bytescCs^t|}t|trt||ko||kSt|tttfr-t|}t||ko,||kSdS)aCase-insensitive match of a single ``str``/``bytes`` command token. ``upper_token`` / ``upper_token_bytes`` must already be upper-cased. The length guard keeps the hot path to a single comparison for a differently sized token (``upper()`` runs only on a size match). F)rrrr!r#r$r%)valuer*r+nr(rrr _token_isgs r.cCs|sdS|d}t|r#t|dkrdS|d|dt|ddfSt|dkrNt|ttrNt|dttrNt|dkr?dS|d|dt|ddfSdS)aDetect an ``HIMPORT SET`` command in ``args`` and return its operands. ``HIMPORT SET`` reaches the raw ``execute_command`` API in two wire-equivalent forms that the serializer both accept: * the joined form ``("HIMPORT SET", key, fieldset, *values)`` (``args[0]`` is the two-word command name the request packer splits on the space), and * the split form ``("HIMPORT", "SET", key, fieldset, *values)``. Both are case- and encoding-insensitive. The connection-state-aware executor and the pipeline pre-flight need the operands at the right offsets for either form, so this returns ``(key, fieldset_name, values_list)`` when ``args`` is an ``HIMPORT SET`` with enough operands, or ``None`` otherwise (a non-``HIMPORT SET`` command, or one with too few operands -- which falls through to the plain send so the server returns its own arity error). Nr)r)rlistr.r_HIMPORT_BYTESr _SET_BYTES)argsfirstrrrparse_himport_set_argsws     r8T)frozenc@s2eZdZUdZeed<eedfed<eed<dS)HImportFieldseta$An immutable HIMPORT fieldset entry. Attributes: name: Fieldset name used by ``HIMPORT SET`` / ``HIMPORT DISCARD``. fields: Ordered field names, exactly as supplied by the caller. They are never reordered or deduplicated (HLD R.2): the server canonicalizes field order internally and rejects duplicate field names, so the client only preserves the caller's positional order. version: Monotonic stamp bumped each time the fieldset is (re)declared. Connections compare the version they last prepared against this value to detect a stale prepared state; the stamp is drawn from the registry's mutation clock (:attr:`HImportRegistry.revision`), which never repeats, so discarding and re-declaring the same name yields a fresh version rather than a colliding one. This is the prepare-side signal; the discard-side counterpart is the clock advancing on removal, since a removed fieldset leaves no entry to stamp. name.rversionN) __name__ __module__ __qualname____doc__r__annotations__tuplerintrrrrr:s  r:c@s@eZdZdZd(ddZdefddZedee de fd d Z d e d e de fd dZd e dee de fddZd e defddZdefddZedefddZdee dee fddZd e de dBfddZdee fddZdee e e ffddZd edefd d!Zdefd"d#Zdee fd$d%Zde fd&d'ZdS))HImportRegistryaClient-level registry of HIMPORT fieldsets. Pure in-memory state, shared by the sync and async clients. It is mutated only through the client's ``himport_prepare`` / ``himport_discard`` / ``himport_discard_all`` methods and exposed read-only through the client's ``himport_registry`` property. Mutations are serialized under a lock so the revision bump and dict change stay consistent when a sync ``Redis`` instance is shared across threads. Reads that iterate or snapshot the registry take the same lock, so a concurrent mutation cannot make them observe a torn view or raise ``dictionary changed size during iteration``; single-key/scalar reads (``get``, ``__contains__``, ``__len__``, :attr:`revision`) are atomic and stay lock-free. The async client runs single-threaded and never contends. The registry always starts empty; fieldsets are declared at runtime through the client's ``himport_prepare`` method. rNcCsi|_t|_d|_dS)Nr) _fieldsets threadingLock_lock _revisionselfrrr__init__s  zHImportRegistry.__init__cCs|jd7_|jS)Nr0rIrJrrr_advanceszHImportRegistry._advancercCs2t|ttttfr tdt|}|std|S)aValidate and materialize the caller's field iterable into a tuple. Done *before* the mutation lock is taken: consuming an arbitrary iterable can be slow, or -- for a generator that inspects this same registry -- can re-enter a locked read (e.g. ``yield`` then ``registry.names()``). Running it under the non-reentrant ``_lock`` would stall every registry user or deadlock permanently. Field order is preserved; nothing is reordered or deduplicated. zWHIMPORT fields must be a collection of field names, not a single string or binary valuez-HIMPORT fieldset must have at least one field)rrr#r$r%rrB)r field_tuplerrr_materialize_fieldssz#HImportRegistry._materialize_fieldsr;rOcCs t|||d}||j|<|S)N)r;rr<)r:rNrE)rKr;rOfieldsetrrr_sets zHImportRegistry._setcCs@||}|j|||WdS1swYdS)zAdd or replace a fieldset, bumping its version, and return the entry. Re-declaring an existing name replaces its fields and bumps its version. Field order is preserved verbatim; nothing is reordered or deduplicated. N)rPrHrR)rKr;rrOrrrprepare s  $zHImportRegistry.preparecCsZ|j ||jvr WddS|j|=| WddS1s&wYdS)zRemove a fieldset from the registry. Returns ``True`` if a fieldset was removed, ``False`` if ``name`` was not registered. Advances :attr:`revision` when a fieldset is actually removed. NFT)rHrErNrKr;rrrdiscards $zHImportRegistry.discardcCsN|jt|j}|r|j||WdS1s wYdS)zRemove all fieldsets and return the number removed. Advances :attr:`revision` when at least one fieldset is removed. N)rHrrEclearrN)rKcountrrr discard_all$s  $zHImportRegistry.discard_allcCs|jS)uMonotonic mutation clock, advanced on every registry change. It is the discard-side counterpart to per-fieldset :attr:`HImportFieldset.version`. A connection records the revision it last reconciled against; when it differs, a discard (or prepare) has occurred since, so the connection recomputes which of its prepared fieldsets are no longer registered — see :meth:`names_to_discard` — and discards those when it is released back to the pool. rMrJrrrrevision6s zHImportRegistry.revisionprepared_namescs<jfdd|DWdS1swYdS)a5Return which of ``prepared_names`` are no longer registered. Given the fieldset names a connection has prepared on the server, this is the set that must be sent ``HIMPORT DISCARD`` (typically when the connection is released), because they have been removed from the registry. csg|] }|jvr|qSrrE).0r;rJrr Nsz4HImportRegistry.names_to_discard..N)rH)rKrZrrJrnames_to_discardCs $z HImportRegistry.names_to_discardcCs |j|S)z;Return the fieldset registered under ``name``, or ``None``.)rEgetrTrrrr_Ps zHImportRegistry.getcCs4|j t|jWdS1swYdS)z%Return the registered fieldset names.N)rHr3rErJrrrnamesTs$zHImportRegistry.namescCs8|jt|jWdS1swYdS)z0Return a snapshot of ``(name, fieldset)`` pairs.N)rHr3rEitemsrJrrrraYs $zHImportRegistry.itemscCs ||jvSNr[rTrrr __contains__^ zHImportRegistry.__contains__cCs t|jSrb)rrErJrrr__len__ardzHImportRegistry.__len__cCs8|jtt|jWdS1swYdSrb)rHiterr3rErJrrr__iter__ds $zHImportRegistry.__iter__cCs\|jt|j}Wdn1swYddd|D}|jjd|dS)Nz, css(|]\}}|dt|jVqdS)=N)r3r)r\r;rQrrr ns z+HImportRegistry.__repr__..())rHr3rErajoin __class__r=)rKentriesbodyrrr__repr__ks zHImportRegistry.__repr__)rN) r=r>r?r@rLrCrN staticmethodrrrBrPrr:rRrSboolrUrXpropertyrYr3r^r_r`raobjectrcrerrgrprrrrrDs(     rD)(r@rFcollections.abcrr dataclassesrredis.exceptionsr redis.typingrrrrrrr _DISCARDALLHIMPORT_PREPAREr"HIMPORT_DISCARDHIMPORT_DISCARDALLrrBrrrrr encoder&rrr)r4r5r#r.r8r:rDrrrrsH    %