o 6 f@sUdZddlZddlZddlmZddlmZmZmZm Z m Z m Z ddlm Z m Z mZmZmZmZmZddlmZmZddlmZmZddlmZdd lmZdd lmZdd lmZd d l m!Z!d dl m"Z#d dl m$Z$d dl m%Z%d dl&m'Z'm(Z(m)Z)m*Z*d dl&m+Z+m,Z,d dl-m.Z.m/Z/d dl0m1Z1d dl2m3Z3m4Z4m5Z5m6Z6m7Z7d dl8m9Z9d dl:m;Z;d dlm?Z?m@Z@d dlAmBZBd dlCmDZDmEZEd dlCmFZFmGZGmHZHd dlImJZJmKZKd dlLmMZMmNZNmOZOd dlPmQZQd d lRmSZSd d!lTmUZUd d"lVmWZWd d#lXmYZYerd d$lZm[Z[m\Z\dd%l]m^Z^ed&Z_e!j`jaZae!j`jbZbe!jcjdZde!jcjeZee!jfjgZge!jfjhZhe!jfjiZie!jjjkZke!jjjlZlemd'ZnGd(d)d)e Zod'eo_pee#jqgdfZreesd*<eeogdfZteesd+<Gd,d-d-e e3ZuGd.d/d/eue3ZvdS)0z psycopg connection objects N) TracebackType)AnyCallablecast GeneratorGenericIterator)List NamedTupleOptionalTypeTypeVarTupleUnion)overload TYPE_CHECKING)ref ReferenceType)warn)partial)contextmanager) TypeAlias)pq)errors)waiting)postgres) AdaptContextParamsQueryRV)PQGen PQGenConn) ComposableSQL)Xid)Row RowFactory tuple_rowTupleRowargs_row) AdaptersMap)IsolationLevel)Cursor) LiteralStringSelf)connection_summary) make_conninfoconninfo_to_dict)conninfo_attemptsConnDicttimeout_from_conninfo) BasePipelinePipeline)notifiesconnectexecute)pgconn_encoding)PrepareManager) Transaction) ServerCursor)ConnectionInfo)PGconnPGresult)BasePool CursorRowpsycopgc@s.eZdZUdZeed< eed< eed<dS)Notifyz8An asynchronous notification received from the database.channelpayloadpidN)__name__ __module__ __qualname____doc__str__annotations__intrPrPK/home/ertert/spirit/venv/lib/python3.10/site-packages/psycopg/connection.pyrEDs rE NoticeHandler NotifyHandlerc @sdeZdZdZejZejZejZejZej Z ej Z ej Z ej Z ej Z ejZejZejZdvddZdwdd Zdefd d Zedefd d ZedefddZedefddZejdeddfddZdeddfddZdededfddZedee fddZ!e!jdee ddfddZ!dee ddfddZ"dee dedfddZ#edeefdd Z$e$jdeeddfd!d Z$deeddfd"d#Z%deededfd$d%Z&edeefd&d'Z'e'jdeeddfd(d'Z'deeddfd)d*Z(deededfd+d,Z)d-ededfd.d/Z*ede+fd0d1Z,ede-fd2d3Z.edxd5d6Z/de0fd7d8Z1dwd9d:Z2e3dyd;d<Z4d=e5ddfd>d?Z6d=e5ddfd@dAZ7e8 B C D E  dzdFdGZ9d=e:ddfdHdIZ;d=e:ddfdJdKZedee0fdOdPZ?e?jdee0ddfdQdPZ?ede0fdRdSZ@e@jde0ddfdTdSZ@e3d{dVedeAeBfdWdXZCeDfdYeEdZejFdeedEfd[d\ZGdwd]d^ZHdedfd_d`ZIdeJfdadbZKdedfdcddZLdedfdedfZMdge0dhediedeNfdjdkZOdlePeNefdedfdmdnZQdedfdodpZRdqeSdlePeNedfdedfdrdsZTdwdtduZUdS)|BaseConnectionz Base class for different types of connections. Share common functionalities such as access to the wrapped PGconn, but allow different interfaces (sync/async). pgconnr@cCs||_d|_d|_g|_g|_d|_d|_t|_d|_ t |}t t j ||_t t j||_|d|_|d|_d|_d|_d|_dS)NFr)rU _autocommit _adapters_notice_handlers_notify_handlers_num_transactions_closedr< _prepared_tpcrrrT_notice_handlernotice_handler_notify_handlernotify_handler _pipeline_isolation_level _read_only _deferrable_begin_statement)selfrUwselfrPrPrQ__init__os& zBaseConnection.__init__returnNcCs<t|dsdS|jr dSt|drdStd|dtdS)NrU_poolz connection zV was deleted while still open. Please use 'with' or '.close()' to close the connection)hasattrclosedrResourceWarningrhrPrPrQ__del__s   zBaseConnection.__del__cCs>|jjd|jj}t|j}d|d|dt|ddS)N.< z at 0xx>) __class__rJrKr0rUid)rhclsinforPrPrQ__repr__s zBaseConnection.__repr__cCs |jjtkS)z$`!True` if the connection is closed.)rUstatusBADrprPrPrQrns zBaseConnection.closedcCs|jjtko |j S)z `!True` if the connection was interrupted. A broken connection is always `closed`, but wasn't closed in a clean way, such as using `close()` or a `!with` block. )rUr|r}r\rprPrPrQbrokenszBaseConnection.brokencC|jS)z'The autocommit state of the connection.)rWrprPrPrQ autocommitszBaseConnection.autocommitvaluecC||dSN)_set_autocommitrhrrPrPrQrcCtrNotImplementedErrorrrPrPrQrzBaseConnection._set_autocommitccs |dEdHt||_dS)Nr)_check_intrans_genboolrWrrPrPrQ_set_autocommit_gensz"BaseConnection._set_autocommit_gencCr)zX The isolation level of the new transactions started on the connection. )rdrprPrPrQisolation_levelzBaseConnection.isolation_levelcCrr)_set_isolation_levelrrPrPrQrrcCrrrrrPrPrQrrz#BaseConnection._set_isolation_levelcc2|dEdH|durt|nd|_d|_dS)NrrV)rr,rdrgrrPrPrQ_set_isolation_level_gen z'BaseConnection._set_isolation_level_gencCr)zX The read-only state of the new transactions started on the connection. )rerprPrPrQ read_onlyrzBaseConnection.read_onlycCrr)_set_read_onlyrrPrPrQrrcCrrrrrPrPrQrrzBaseConnection._set_read_onlyccr)NrrV)rrrergrrPrPrQ_set_read_only_genrz!BaseConnection._set_read_only_gencCr)zY The deferrable state of the new transactions started on the connection. )rfrprPrPrQ deferrablerzBaseConnection.deferrablecCrr)_set_deferrablerrPrPrQrrcCrrrrrPrPrQrrzBaseConnection._set_deferrableccr)NrrV)rrrfrgrrPrPrQ_set_deferrable_genrz"BaseConnection._set_deferrable_gen attributeccsr|jj}|tkr|jr|jEdH|jj}|tkr7|jr(td|dtd|dt |j dS)Nz can't change z2 now: connection.transaction() context in progressz' now: connection in transaction status ) rUtransaction_statusIDLErc _sync_genr[eProgrammingErrorrTransactionStatusname)rhrr|rPrPrQrs   z!BaseConnection._check_intrans_gencCs t|jS)z>A `ConnectionInfo` attribute to inspect connection properties.)r?rUrprPrPrQrzs zBaseConnection.infocCs|js ttj|_|jSr)rXr+radaptersrprPrPrQrs zBaseConnection.adaptersBaseConnection[Row]cC|SrrPrprPrPrQ connection!zBaseConnection.connectioncC|jjS)zReturn the file descriptor of the connection. This function allows to use the connection as file-like object in functions waiting for readiness, such as the ones defined in the `selectors` module. )rUsocketrprPrPrQfileno&zBaseConnection.filenocCs4|jrdS|jr|jdrtd||jdS)z/Cancel the current operation on the connection.Nrz=cancel() cannot be used with a prepared two-phase transaction)rnr^rr _try_cancelrUrprPrPrQcancel/szBaseConnection.cancelc CsLz|}Wnty}z td|WYd}~dSd}~ww|dS)Nz couldn't try to cancel query: %s) get_cancel Exceptionloggerwarningr)ryrUcexrPrPrQr>s  zBaseConnection._try_cancelcallbackcC|j|dS)z Register a callable to be invoked when a notice message is received. :param callback: the callback to call upon message received. :type callback: Callable[[~psycopg.errors.Diagnostic], None] N)rYappendrhrrPrPrQadd_notice_handlerHz!BaseConnection.add_notice_handlercCr)z Unregister a notice message callable previously registered. :param callback: the callback to remove. :type callback: Callable[[~psycopg.errors.Diagnostic], None] N)rYremoverrPrPrQremove_notice_handlerQrz$BaseConnection.remove_notice_handlerri"ReferenceType[BaseConnection[Row]]resrAc Cst|}|r|js dSt|t|j}|jD]!}z||Wqty7}z td||WYd}~qd}~wwdS)Nz)error processing notice callback '%s': %s)rYr Diagnosticr;rUrr exception)rirrhdiagcbrrPrPrQr_Zs   zBaseConnection._notice_handlercCr)z Register a callable to be invoked whenever a notification is received. :param callback: the callback to call upon notification received. :type callback: Callable[[~psycopg.Notify], None] N)rZrrrPrPrQadd_notify_handlerirz!BaseConnection.add_notify_handlercCr)z Unregister a notification callable previously registered. :param callback: the callback to remove. :type callback: Callable[[~psycopg.Notify], None] N)rZrrrPrPrQremove_notify_handlerrrz$BaseConnection.remove_notify_handlerpgncCsT|}|r|js dSt|j}t|j||j||j}|jD]}||q!dSr)rZr;rUrErelnamedecodeextrabe_pid)rirrhencnrrPrPrQra{s    zBaseConnection._notify_handlercCr)a& Number of times a query is executed before it is prepared. - If it is set to 0, every query is prepared the first time it is executed. - If it is set to `!None`, prepared statements are disabled on the connection. Default value: 5 r]prepare_thresholdrprPrPrQrs z BaseConnection.prepare_thresholdcC ||j_dSrrrrPrPrQr cCr)zf Maximum number of prepared statements on the connection. Default value: 100 r] prepared_maxrprPrPrQrrzBaseConnection.prepared_maxcCrrrrrPrPrQrrconninfoccst|EdH}||}|S)z?Generator to connect to the database and create a new instance.N)r9)ryrrUconnrPrPrQ _connect_genszBaseConnection._connect_gencommand result_formatccs|t|tr|t|j}n t|tr||}|jr:t |jj |d|d}|jj ||jj ddS|jj |d|dt|jEdHd}|jtkrx|jtkrx|jtkrftj|t|jdtdt|jjd||S)z Generator to send a command and receive the result to the backend. Only used to implement internal commands such as "commit", with eventual arguments bound client-side. The cursor can do more complex stuff. N)r)encodingzunexpected result z from command )_check_connection_ok isinstancerMencoder;rUr#as_bytesrcrsend_query_params command_queuer result_queuer:r| COMMAND_OK TUPLES_OK FATAL_ERRORrerror_from_resultInterfaceErrorr ExecStatusrr)rhrrcmdresultrPrPrQ _exec_commands6    zBaseConnection._exec_commandcCs:|jjtkrdS|jjtkrtdtd|jj)Nzthe connection is closedz7cannot execute operations: the connection is in status )rUr|OKr}rOperationalErrorrrprPrPrQrs   z#BaseConnection._check_connection_okccsN|jrdS|jjtkrdS||EdH|jr%|jEdHdSdS)z.Generator to start a transaction if necessary.N)rWrUrrr_get_tx_start_commandrcrrprPrPrQ _start_querys zBaseConnection._start_querycCs|jr|jSdg}|jdur$t|j}|d||jdd|jdur3||jr0dnd|jdurB||jr?dndd ||_|jS) NsBEGINsISOLATION LEVEL_rts READ ONLYs READ WRITEs DEFERRABLEsNOT DEFERRABLE ) rgrr,rrreplacerrrjoin)rhpartsvalrPrPrQrs      z$BaseConnection._get_tx_start_commandccs`|jr td|jrtd|jjtkrdS|dEdH|jr.|j EdHdSdS)z-Generator implementing `Connection.commit()`.zExplicit commit() forbidden within a Transaction context. (Transaction will be automatically committed on successful exit from context.)z6commit() cannot be used during a two-phase transactionNsCOMMIT) r[rrr^rUrrrrcrrprPrPrQ _commit_gen s zBaseConnection._commit_genccs|jr td|jrtd|jr|jEdH|jjtkr$dS| dEdH|j |j D] }| |EdHq6|jrN|jEdHdSdS)z/Generator implementing `Connection.rollback()`.zExplicit rollback() forbidden within a Transaction context. (Either raise Rollback() or allow an exception to propagate out of the context.)z8rollback() cannot be used during a two-phase transactionNsROLLBACK) r[rrr^rcrrUrrrr]clearget_maintenance_commands)rhrrPrPrQ _rollback_gens(  zBaseConnection._rollback_gen format_idgtridbqualcCs|t|||S)aL Returns a `Xid` to pass to the `!tpc_*()` methods of this connection. The argument types and constraints are explained in :ref:`two-phase-commit`. The values passed to the method will be available on the returned object as the members `~Xid.format_id`, `~Xid.gtrid`, `~Xid.bqual`. ) _check_tpcr% from_parts)rhrrrrPrPrQxid;s zBaseConnection.xidrccsx|t|tst|}|jjtkr#tdt |jjj |j r+td|df|_ ||EdHdS)Nz8can't start two-phase transaction: connection in status z3can't use two-phase transactions in autocommit modeF)rrr% from_stringrUrrrrrrrrWr^rrrhrrPrPrQ_tpc_begin_genHs     zBaseConnection._tpc_begin_genccsv|js td|jdrtd|jd}|df|_|tdt|EdH|jr9|jEdHdSdS)Nz='tpc_prepare()' must be called inside a two-phase transactionrzF'tpc_prepare()' cannot be used during a prepared two-phase transactionrTzPREPARE TRANSACTION {}) r^rrrr$formatrMrcrrrPrPrQ_tpc_prepare_gen\s   zBaseConnection._tpc_prepare_genactionccsd|d}|dur|jst|d|jd}n|jr)t|dt|ts3t|}|jrQ|jdsQt|d|d}d|_|EdHdS|t d  t |t |EdHd|_dS) Ntpc_z()z? without xid must must be called inside a two-phase transactionrz= with xid must must be called outside a two-phase transactionrr_genz{} PREPARED {}) lowerr^rrrr%rgetattrrr$rrM)rhrrfnamemethrPrPrQ_tpc_finish_genks,    zBaseConnection._tpc_finish_gencCsdS)z0Raise NotSupportedError if TPC is not supported.NrPrprPrPrQrrzBaseConnection._check_tpc)rUr@rkN)rkr)rUr@rkN)rirrrArkNr)VrIrJrKrLrWarningErrorr DatabaseError DataErrorrIntegrityError InternalErrorrNotSupportedErrorr ConnStatusrrjrqrMr{propertyrrnr~rsetterrr!rr r,rrrrrrrrrrr?rzr+rrrOrr classmethodrrRrr staticmethodr_rSrrPGnotifyrarrr"r/rTEXTrFormatrrrbytesrrrr%rrrrr.rrrPrPrPrQrTWs  #                (     rTcseZdZUdZdZeeeed<eeeed<e eed<e e ed<e e ee fddde effd d Zee dbd d ddddedede ede ede eeede ededeefddfddZee dbd d ddddedede ede eeede ededeefddfddZe dbd d dddddedede ede e ede eeede ededefddZdefddZde eed e ed!e eddfd"d#Zedededefd$d%Zdcd&d'Zed d(d)edeefd*d+Z ed d(d)ede e!dee!fd,d+Z ed dd d-d.ed)ed/e ed0edeef d1d+Z ed dd d-d.ed)ede e!d/e ed0edee!f d2d+Z dbd ddd d3d.ed)ede e ed/e ed0edeeeeeff d4d+Z dddd d5d6e"d7e e#d8e ed)edeef d9d:Z$dcd;d<Z%dcd=d>Z&e'  ded?e ed@ede(e)fdAdBZ*de+e,ddffdCdDZ-e'de(e fdEdFZ.dfdHe/e0dIe e1de0fdJdKZ2edHe3e0dIe ede0fdLdMZ4dNeddfdOdPZ5dNe e6ddfdQdRZ7dNe eddfdSdTZ8dNe eddfdUdVZ9dWee:efddfdXdYZ;dcdZd[Zde?e:fd`daZ@ZAS)g Connectionz3 Wrapper for a connection to the database. rDcursor_factoryserver_cursor_factory row_factoryrcrUr@cs,t|||_t|_t|_t|_ dSr) superrjr threadingLocklockr-rr>r)rhrUrrwrPrQrjs   zConnection.__init__rFN)rrrcontextrrrr%kwargsrkzConnection[Row]cKdSrrP)ryrrrrrr%r&rPrPrQr9szConnection.connectzConnection[TupleRow]cKr'rrP)ryrrrrr%r&rPrPrQr9s )rrrrr%c Ks|j|fi|}t|} d} t|} | D]E} ztdi| }|j||| d} Wn/tjyZ} z"t| dkrNt d| d| d| dt | | }WYd} ~ qd} ~ ww| sf|saJ| dt|| _|rp|| _|ru|| _|r}t|j| _|| _| S) zV Connect to a database server and return a new `Connection` instance. NtimeoutrzAconnection attempt failed on host: %r, port: %r, hostaddr: %r: %shostporthostaddrrP)_get_connection_paramsr5r3r1 _wait_connrr _NO_TRACEBACKlenrdebuggetrMwith_tracebackrrWrrr+rrXr)ryrrrrrr%r&paramsr)rvattemptsattemptrlast_exrPrPrQr9sB     cCrrrPrprPrPrQ __enter__rzConnection.__enter__exc_typeexc_valexc_tbc Csr|jrdS|r'z|Wnty&}z td||WYd}~n d}~ww|t|dds7|dSdS)Nz#error ignored in rollback on %s: %srl)rnrollbackrrrcommitrclose)rhr:r;r<exc2rPrPrQ__exit__s"   zConnection.__exit__cKst|fi|S)amManipulate connection parameters before connecting. :param conninfo: Connection string as received by `~Connection.connect()`. :param kwargs: Overriding connection arguments as received by `!connect()`. :return: Connection arguments merged and eventually modified, in a format similar to `~conninfo.conninfo_to_dict()`. )r2)ryrr&rPrPrQr-s z!Connection._get_connection_paramscCs|jrdSd|_|jdS)zClose the database connection.NT)rnr\rUfinishrprPrPrQr?!szConnection.close)binaryrCcCr'rrP)rhrCrPrPrQcursor+rzConnection.cursorcCr'rrP)rhrCrrPrPrQrD.r)rC scrollablewithholdrrErFcCr'rrP)rhrrCrErFrPrPrQrD3scCr'rrP)rhrrCrrErFrPrPrQrD=s )rCrrErFcCsH||s |j}|r|j|||||d}n|j||d}|r"t|_|S)zU Return a new cursor to send commands and queries to the connection. )rrrErFr)rrrrBINARYr)rhrrCrrErFcurrPrPrQrDHs )preparerCqueryr4rJc CsJz|}|r t|_|j|||dWStjy$}z|dd}~ww)z8Execute a query and return a cursor to read its results.)rJN)rDrHrr:rr/r3)rhrKr4rJrCrIrrPrPrQr:js  zConnection.executecC:|j||WddS1swYdS)z/Commit any pending transaction to the database.N)r"waitrrprPrPrQr>}"zConnection.commitcCrL)z2Roll back to the start of any pending transaction.N)r"rMrrprPrPrQr=rNzConnection.rollbacksavepoint_nameforce_rollbackc cst|||}|jrR|:|| |VWdn1s$wYWdn1s3wYWddSWddS1sKwYdS| |VWddS1scwYdS)a Start a context block with a new transaction or nested transaction. :param savepoint_name: Name of the savepoint used to manage a nested transaction. If `!None`, one will be chosen automatically. :param force_rollback: Roll back the transaction at the end of the block even if there were no error (e.g. to try a no-op process). :rtype: Transaction N)r=rcpipeline)rhrOrPtxrPrPrQ transactions P"zConnection.transactionc cs |j%z |t|j}Wntjy"}z|dd}~wwWdn1s-wYt|j}|D]}t|j ||j ||j }|Vq9q)zX Yield `Notify` objects as soon as they are received from the database. TN) r"rMr8rUrr/r3r;rErrrr)rhnsrrrrrPrPrQr8s   zConnection.notifiesccs|j||j}|durt|}|_Wdn1s!wYz=| |VWdn1s7wYW|jdkrb|j||jusMJd|_WddS1s[wYdSdS|jdkr|j||justJd|_Wdw1swYw)z)Switch the connection into pipeline mode.Nr)r"rrcr7level)rhrQrPrPrQrQs. "zConnection.pipeline皙?genr)c Cs`z tj||jj|dWSty/||jz tj||jj|dWtjy.Yww)z Consume a generator operating on the connection. The function must be used on generators that don't change connection fd (i.e. not on connect and reset). r()rrMrUrKeyboardInterruptrr QueryCanceled)rhrWr)rPrPrQrMs  zConnection.waitcCstj||dS)zConsume a connection generator.r()r wait_conn)ryrWr)rPrPrQr.szConnection._wait_connrcC<|j|||WddS1swYdSr)r"rMrrrPrPrQr"zConnection._set_autocommitcCr[r)r"rMrrrPrPrQrr\zConnection._set_isolation_levelcCr[r)r"rMrrrPrPrQrr\zConnection._set_read_onlycCr[r)r"rMrrrPrPrQrr\zConnection._set_deferrablercCs<|j|||WddS1swYdS)zO Begin a TPC transaction with the given transaction ID `!xid`. N)r"rMrrrPrPrQ tpc_begins"zConnection.tpc_beginc Csjz|j||WdWdS1swYWdStjy4}ztt|dd}~ww)zV Perform the first phase of a transaction started with `tpc_begin()`. N)r"rMrrObjectNotInPrerequisiteStaterrM)rhrrPrPrQ tpc_prepares&zConnection.tpc_preparecC>|j||d|WddS1swYdS)z: Commit a prepared two-phase transaction. COMMITNr"rMrrrPrPrQ tpc_commit"zConnection.tpc_commitcCr`)z= Roll back a prepared two-phase transaction. ROLLBACKNrbrrPrPrQ tpc_rollbackrdzConnection.tpc_rollbackcCsx||jj}|jttjd}|t| }Wdn1s'wY|t kr:|jjt kr:| |S)NrG) rrzrrDr*r% _from_recordr:_get_recover_queryfetchallrINTRANSr=)rhr|rIrrPrPrQ tpc_recovers zConnection.tpc_recoverr r r)NF)rV)BrIrJrKrLr r-r&rNr>r'r r7rr(rjrrrMrrOrrr9rr/r9 BaseExceptionrrAr4r-r?rDrCrrr:r>r=rrr=rSrrEr8rQr!r floatrMr"r.rr,rrrr%r]r_rcrfr rk __classcell__rPrPr#rQrs             1           %       r)wrLloggingr typesrtypingrrrrrrr r r r r rrrrweakrefrrwarningsr functoolsr contextlibrtyping_extensionsrrrrrrrabcrrrr r!r"sqlr#r$r^r%rowsr&r'r(r)r*adaptr+_enumsr,rDr-_compatr.r/pq.miscr0rr1r2r3r4r5rcr6r7 generatorsr8r9r: _encodingsr; _preparingr<rSr= server_cursorr>_connection_infor?pq.abcr@rApsycopg_pool.baserBrCrrrHrrr}rrrrrrrj getLoggerrrErJrrRrNrSrTrrPrPrPrQsv  $                     =