U ڲg)@sdZddlmZddlmZmZmZddlmZddlm Z ddl m Z m Z ddlmZdd lmZdd lmZdd lmZerdd lmZed ZGdddZeedZeedZdS)z, Mapping from types/oids to Dumpers/Loaders ) annotations)Anycast TYPE_CHECKING)pq)errors)DumperLoader)PyFormat)TypeVar)_psycopg) TypesRegistry)BaseConnectionRVc@seZdZUdZdZded<ded<ded<d ed <iZd ed <d5dddddZeddddZeddddZ ddddddZ dd dd!d"d#Z d$d%dd&d'd(Z d)d*dd+d,d-Z d)d*d.d+d/d0Zed1d1d2d3d4Zd S)6 AdaptersMapa Establish how types should be converted between Python and PostgreSQL in an `~psycopg.abc.AdaptContext`. `!AdaptersMap` maps Python types to `~psycopg.adapt.Dumper` classes to define how Python types are converted to PostgreSQL, and maps OIDs to `~psycopg.adapt.Loader` classes to establish how query results are converted to Python. Every `!AdaptContext` object has an underlying `!AdaptersMap` defining how types are converted in that context, exposed as the `~psycopg.abc.AdaptContext.adapters` attribute: changing such map allows to customise adaptation in a context without changing separated contexts. When a context is created from another context (for instance when a `~psycopg.Cursor` is created from a `~psycopg.Connection`), the parent's `!adapters` are used as template for the child's `!adapters`, so that every cursor created from the same connection use the connection's types configuration, but separate connections have independent mappings. Once created, `!AdaptersMap` are independent. This means that objects already created are not affected if a wider scope (e.g. the global one) is changed. The connections adapters are initialised using a global `!AdptersMap` template, exposed as `psycopg.adapters`: changing such mapping allows to customise the type mapping for every connections created afterwards. The object can start empty or copy from another object of the same class. Copies are copy-on-write: if the maps are updated make a copy. This way extending e.g. global map by a connection or a connection map from a cursor is cheap: a copy is only made on customisation. z psycopg.adaptrtypesz.dict[PyFormat, dict[type | str, type[Dumper]]]_dumperszlist[dict[int, type[Dumper]]]_dumpers_by_oidzlist[dict[int, type[Loader]]]_loaderszdict[type, type] _optimisedNzAdaptersMap | NonezTypesRegistry | None)templatercCs|rz|j|_t|_t|_|jdd|_ddg|_ddg|_|jdd|_ddg|_ddg|_t|j |_ nNddt D|_t |_iig|_ddg|_iig|_ddg|_|pt|_ dS)NFcSsi|] }|iqSr).0fmtrr9/tmp/pip-unpacked-wheel-b_ea6rx_/psycopg/_adapters_map.py \sz(AdaptersMap.__init__..T) rcopy_dumpers_shared _own_dumpersr_own_dumpers_by_oidr _own_loadersrrr _dumpers_owned)selfrrrrr__init__Gs$            zAdaptersMap.__init__)returncCs|SNrr#rrradaptershszAdaptersMap.adapterszBaseConnection[Any] | NonecCsdSr&rr'rrr connectionlszAdaptersMap.connectionztype | str | Nonez type[Dumper]None)clsdumperr%cCs|dks&t|ttfs&td|dtr4||}|rt|jtj fD]:}|j |sv|j | |j |<d|j |<||j ||<qJ|j r|j|js|j|j |j|j<d|j|j<||j|j|j <dS)a Configure the context to use `!dumper` to convert objects of type `!cls`. If two dumpers with different `~Dumper.format` are registered for the same type, the last one registered will be chosen when the query doesn't specify a format (i.e. when the value is used with a ``%s`` "`~PyFormat.AUTO`" placeholder). :param cls: The type to manage. :param dumper: The dumper to register for `!cls`. If `!cls` is specified as string it will be lazy-loaded, so that it will be possible to register it without importing it before. In this case it should be the fully qualified name of the object (e.g. ``"uuid.UUID"``). If `!cls` is None, only use the dumper when looking up using `get_dumper_by_oid()`, which happens when we know the Postgres type to adapt to, but not the Python type that will be adapted (e.g. in COPY after using `~psycopg.Copy.set_types()`). Nz-dumpers should be registered on classes, got  insteadT) isinstancestrtype TypeErrorr _get_optimisedr Zfrom_pqformatZAUTOrrroidr r)r#r+r,rrrrregister_dumperps&      zAdaptersMap.register_dumperz int | strz type[Loader])r4loaderr%cCs~t|tr|j|j}t|ts0td|dtr>||}|j}|j |sl|j | |j |<d|j |<||j ||<dS)aH Configure the context to use `!loader` to convert data of oid `!oid`. :param oid: The PostgreSQL OID or type name to manage. :param loader: The loar to register for `!oid`. If `oid` is specified as string, it refers to a type name, which is looked up in the `types` registry. z)loaders should be registered on oid, got r-TN) r.r/rr4intr1r r2r3r!rr)r#r4r6rrrrregister_loaders      zAdaptersMap.register_loaderr0r )r+r3r%c Csz|j||WStk rF||jkr8td||j|}YnX|jD]J}||krf||S|jd|j}||krN||}||<|SqNt|}t d|j d|j d|j ddS)aL Return the dumper class for the given type and format. Raise `~psycopg.ProgrammingError` if a class is not available. :param cls: The class to adapt. :param format: The format to dump to. If `~psycopg.adapt.PyFormat.AUTO`, use the last one of the dumpers registered on `!cls`. bad dumper format: .zcannot adapt type z using placeholder '%z ' (format: )N) rKeyError ValueError__mro__ __module__ __qualname__popr eProgrammingError__name__valuename)r#r+r3dmapZsclsZfqndrrr get_dumpers"     zAdaptersMap.get_dumperr7z pq.Format)r4r3r%c Csz|j|}Wn"tk r0td|YnXz ||WStk r|j|}|r~d|jd|dt|j}nd|dt|j}t |YnXdS)z Return the dumper class for the given oid and format. Raise `~psycopg.ProgrammingError` if a class is not available. :param oid: The oid of the type to dump to. :param format: The format to dump to. r9zcannot find a dumper for type z (oid z ) format z/cannot find a dumper for unknown type with oid z format N) rr<r=rgetrFrZFormatrBrC)r#r4r3rGinfomsgrrrget_dumper_by_oids   zAdaptersMap.get_dumper_by_oidztype[Loader] | NonecCs|j||S)z Return the loader class for the given oid and format. Return `!None` if not found. :param oid: The oid of the type to load. :param format: The format to load from. )rrJ)r#r4r3rrr get_loaders zAdaptersMap.get_loadertype[RV])r+r%cCspz |j|WStk r YnXddlm}|j|jrbtdtt |jd}|rb||j|<|S||j|<|S)zReturn the optimised version of a Dumper or Loader class. Return the input class itself if there is no optimised version. r)rrON) rr<Zpsycopgrr? startswithrDrgetattrr )r#r+rnewrrrr2 s    zAdaptersMap._get_optimised)NN)rDr?r@__doc____annotations__rr$propertyr(r)r5r8rIrMrN classmethodr2rrrrrs* " !3' rTFN)rS __future__rtypingrrrrrrBabcr r Z_enumsr _compatr Z_cmoduler Z _typeinforZ_connection_baserrrdictfromkeysr"rrrrrs"