>|hj+pdZddlmZddlmZddlmZGddeZ Gdd e Z e Z Gd d Z y ) a. SteadyPg - hardened classic PyGreSQL connections. Implements steady connections to a PostgreSQL database using the classic (not DB-API 2 compliant) PyGreSQL API. The connections are transparently reopened when they are closed or the database connection has been lost or when they are used more often than an optional usage limit. Only connections which have been marked as being in a database transaction with a begin() call will not be silently replaced. A typical situation where database connections are lost is when the database server or an intervening firewall is shutdown and restarted for maintenance reasons. In such a case, all database connections would become unusable, even though the database service may be already available again. The "hardened" connections provided by this module will make the database connections immediately available again. This results in a steady PostgreSQL connection that can be used by PooledPg or PersistentPg to create pooled or persistent connections to a PostgreSQL database in a threaded environment such as the application server of "Webware for Python." Note, however, that the connections themselves are not thread-safe. For more information on PostgreSQL, see: https://www.postgresql.org/ For more information on PyGreSQL, see: http://www.pygresql.org For more information on Webware for Python, see: https://webwareforpython.github.io/w4py/ Usage: You can use the class SteadyPgConnection in the same way as you would use the class DB from the classic PyGreSQL API module db. The only difference is that you may specify a usage limit as the first parameter when you open a connection (set it to None if you prefer unlimited usage), and an optional list of commands that may serve to prepare the session as the second parameter, and you can specify whether is is allowed to close the connection (by default this is true). When the connection to the PostgreSQL database is lost or has been used too often, it will be automatically reset, without further notice. from dbutils.steady_pg import SteadyPgConnection db = SteadyPgConnection(10000, ["set datestyle to german"], host=..., dbname=..., user=..., ...) ... result = db.query('...') ... db.close() Ideas for improvement: * Alternatively to the maximum number of uses, implement a maximum time to live for connections. * Optionally log usage and loss of connection. Copyright, credits and license: * Contributed as supplement for Webware for Python and PyGreSQL by Christoph Zwerschke in September 2005 Licensed under the MIT license. )suppress)DB) __version__ceZdZdZy) SteadyPgErrorzGeneral SteadyPg error.N__name__ __module__ __qualname____doc__P/var/www/html/test/engine/venv/lib/python3.12/site-packages/dbutils/steady_pg.pyrrOs!rrceZdZdZy)InvalidConnectionErrorzDatabase connection is invalid.Nr rrrrrSs)rrczeZdZdZeZ ddZdZdZdZ dZ dZ d Z d Z dd Zdd Zdd ZddZdZdZdZy)SteadyPgConnectionaClass representing steady connections to a PostgreSQL database. Underlying the connection is a classic PyGreSQL pg API database connection which is reset if the connection is lost or used too often. Thus the resulting connection is steadier ("tough and self-healing"). If you want the connection to be persistent in a threaded environment, then you should not deal with this class directly, but use either the PooledPg module or the PersistentPg module to get the connections. Ncd|_d|_|d}t|ts t d||_||_||_t|i||_d|_ d|_|jd|_ y)aCreate a "tough" PostgreSQL connection. A hardened version of the DB wrapper class of PyGreSQL. maxusage: maximum usage limit for the underlying PyGreSQL connection (number of uses, 0 or None means unlimited usage) When this limit is reached, the connection is automatically reset. setsession: optional list of SQL commands that may serve to prepare the session, e.g. ["set datestyle to ...", "set time zone ..."] closeable: if this is set to false, then closing the connection will be silently ignored, but by default the connection can be closed args, kwargs: the parameters that shall be used to establish the PostgreSQL connections with PyGreSQL using pg.DB() NTrz$'maxusage' must be an integer value.F) _con_closed isinstanceint TypeError _maxusage_setsession_sql _closeable PgConnection _transaction _setsession_usage)selfmaxusage setsession closeableargskwargss r__init__zSteadyPgConnection.__init__is|$   H(C(BC C!)# $1&1 !   rc&|j|S)z9Enter the runtime context. This will start a transaction.)beginr"s r __enter__zSteadyPgConnection.__enter__s  rcd|d|d|d|jy|jy)z8Exit the runtime context. This will end the transaction.rNr)commitrollback)r"excs r__exit__zSteadyPgConnection.__exit__s- q6>c!fnQ KKM MMOrcv|jr-|jD]}|jj|yy)z1Execute the SQL commands for session preparation.N)rrquery)r"sqls rr zSteadyPgConnection._setsessions5   ++ % $ % rc|jsAtt5|jj dddd|_d|_yy#1swYxYw)zClose the tough connection. You can always close a tough connection with this method, and it will not complain if you close it more than once. NFT)rr Exceptionrcloserr+s r_closezSteadyPgConnection._closesJ ||)$ " ! " %D DL  " "s AAcx|jr|jy|jr|jyy)a^Close the tough connection. You are allowed to close a tough connection by default, and it will not complain if you close it more than once. You can disallow closing connections by setting the closeable parameter to something false. In this case, closing tough connections will be silently ignored. N)rr9rresetr+s rr8zSteadyPgConnection.closes+ ?? KKM    JJLrcL |jjd|_d|_|j d|_y#t $rX|jrId|_tt 5|jjddddYy#1swYYyxYwYywxYw)ziReopen the tough connection. It will not complain if the connection cannot be reopened. Frr0N) rreopenrrr r!r7rr4r+s rr=zSteadyPgConnection.reopens  II   !&D  DL    DK 0  $)!i(0IIOOJ/000! 0s/A+B#-B B#B B#B#"B#cF |jjd|_|jd|_y#t $r\ |j Yy#t $r<tt 5|jdddn#1swYnxYwYYyYYywxYwwxYw)zReset the tough connection. If a reset is not possible, tries to reopen the connection. It will not complain if the connection is already closed. FrN) rr;rr r!r7r=rr0r+s rr;zSteadyPgConnection.resets $ IIOO  %D     DK $ $  $i($MMO$$$$ $ $sE8; B AB/B  B B BB B BB cd|_ |jj}|r ||S|S#t$r"|jj |xsdcYSwxYw)zBegin a transaction.Tr5r*)rrr*AttributeErrorr4)r"r5r*s rr*zSteadyPgConnection.beginsY  6IIOOE &)5S> 5eg 5  399??3>'2 2 31(AAcd|_ |jj}|r ||S|S#t$r"|jj |xsdcYSwxYw)Commit the current transaction.Fr@end)rrrErAr4)r"r5rEs rrEzSteadyPgConnection.endsY! 2))--C$'33< 1CE 1 199??3<%0 0 1rBcd|_ |jj}|r ||S|S#t$r"|jj |xsdcYSwxYw)rDFr@r/)rrr/rAr4)r"r5r/s rr/zSteadyPgConnection.commits[! 8YY%%F'*6c? 7vx 7 499??3?(3 3 4rBcd|_ |jj}|r ||S|S#t$r"|jj |xsdcYSwxYw)z!Rollback the current transaction.Fr@r0)rrr0rAr4)r"r5r0s rr0zSteadyPgConnection.rollbacks]! <yy))H),8$ ; ; 699??3#4*5 5 6rBcfd}|S)aReturn a "tough" version of a connection class method. The tough version checks whether the connection is bad (lost) and automatically and transparently tries to reset the connection if this is the case (for instance, the database has been restarted). cj}|sL jjjr%jrj jk\rt  |i|}xj dz c_|S#t$rjY;wxYw#t$rF|rd_jjjrj|i|}YwxYw)NFr) rrdbstatusrr!rAr7r;)r&r' transactionresultmethodr"s r tough_methodz:SteadyPgConnection._get_tough_method..tough_method s++K! 99<<.. NNt{{dnn/L,, 100 KK1 KM!!JJL! 1(-D%99<<&& 00 1s%A A<B<BBA C*)C*r)r"rNrOs`` r_get_tough_methodz$SteadyPgConnection._get_tough_methods .rc|jr>t|j|}|dvs|jdr|j|}|St)zInherit the members of the standard connection class. Some methods are made "tougher" than in the standard version. )r4getinsertupdatedeleteget_)rgetattr startswithrPr)r"nameattrs r __getattr__zSteadyPgConnection.__getattr__%sK 99499d+DFFv.--d3K$$rc4 |jy#YyxYw)zDelete the steady connection.N)r9r+s r__del__zSteadyPgConnection.__del__2s  KKM  s)NNT)N)r r r r rversionr(r,r2r r9r8r=r;r*rEr/r0rPr[r]rrrrr[sa G=A D %   $$$ 628<@ %rrN) r contextlibrpgrrrr7rrInvalidConnectionrrrrrcsCEN !"I"*]* +]]r