File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/enterprise.zip
Back
PK v��ZR��> > " __pycache__/adbapi.cpython-310.pycnu �[��� o �bA � @ sf d Z ddlmZ ddlmZmZ G dd� de�ZG dd� d�ZG dd � d �Z G d d � d �Z d d gZ d S ) zg An asynchronous mapping to U{DB-API 2.0<http://www.python.org/topics/database/DatabaseAPI-2.0.html>}. � )�threads)�log�reflectc @ s e Zd ZdZdS )�ConnectionLostzb This exception means that a db connection has been lost. Client code may try again. N)�__name__� __module__� __qualname__�__doc__� r r �;/usr/lib/python3/dist-packages/twisted/enterprise/adbapi.pyr s r c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � Connectiona A wrapper for a DB-API connection instance. The wrapper passes almost everything to the wrapped connection and so has the same API. However, the L{Connection} knows about its pool and also handle reconnecting should when the real connection dies. c C s || _ d | _| �� d S �N)�_pool� _connection� reconnect)�self�poolr r r �__init__ � zConnection.__init__c C s d S r r �r r r r �close$ s zConnection.closec C s� | j js | j�� d S z | j�� | j�� }|�| j j� |�� | j�� W d S t y7 t � d d� Y nw | j � | j� | j j rHt �d� t� �)N�Rollback failedzConnection lost.)r r r �rollback�cursor�execute�good_sqlr �commit� BaseExceptionr �err� disconnect�noisy�msgr )r �cursr r r r . s" � zConnection.rollbackc C s( | j d ur | j�| j � | j�� | _ d S r )r r r �connectr r r r r D s zConnection.reconnectc C � t | j|�S r )�getattrr �r �namer r r � __getattr__I � zConnection.__getattr__N) r r r r r r r r r( r r r r r s r c @ s< e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z dS ) � Transactiona A lightweight wrapper for a DB-API 'cursor' object. Relays attribute access to the DB cursor. That is, you can call C{execute()}, C{fetchall()}, etc., and they will be called on the underlying DB-API cursor object. Attributes will also be retrieved from there. Nc C s || _ || _| �� d S r )r r �reopen)r r � connectionr r r r Y r zTransaction.__init__c C s | j }d | _ |�� d S r )�_cursorr )r r- r r r r ^ r zTransaction.closec C sx | j d ur | �� z | j�� | _ W d S ty& | jjs � t�d d� Y nw | jj r0t� d� | �� | j�� | _ d S )NzCursor creation failedz Connection lost, reconnecting) r- r r r r r r r r r r! r r r r r+ c s � zTransaction.reopenc C s | j �� d | _d S r )r r r- r r r r r v s zTransaction.reconnectc C r$ r )r% r- r& r r r r( z r) zTransaction.__getattr__) r r r r r- r r r+ r r( r r r r r* M s r* c @ s� e Zd ZdZd�� ZdZdZdZdZ dZ dZ dZ dZ eZeZdZdd � Zd d � Zd d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Z d d � Z d d � Z d d!� Z d"d#� Z d$d%� Z!d&d'� Z"d(d)� Z#d*d+� Z$dS ),�ConnectionPoola� Represent a pool of connections to a DB-API 2.0 compliant database. @ivar connectionFactory: factory for connections, default to L{Connection}. @type connectionFactory: any callable. @ivar transactionFactory: factory for transactions, default to L{Transaction}. @type transactionFactory: any callable @ivar shutdownID: L{None} or a handle on the shutdown event trigger which will be used to stop the connection pool workers when the reactor stops. @ivar _reactor: The reactor which will be used to schedule startup and shutdown events. @type _reactor: L{IReactorCore} provider z-min max name noisy openfun reconnect good_sqlF� � Nzselect 1c O s || _ t�|�| _t| jdd�dkrt�d� t| jdd�dk r%t�d� |�d d�}|du r5dd lm } || _ || _ || _ | j D ]}d |� �}||v rWt| ||| � ||= qAt| j| j�| _t| j| j�| _i | _dd lm}m} |j| _|�| j| j�| _| j �| j�| _dS ) a� Create a new L{ConnectionPool}. Any positional or keyword arguments other than those documented here are passed to the DB-API object when connecting. Use these arguments to pass database names, usernames, passwords, etc. @param dbapiName: an import string to use to obtain a DB-API compatible module (e.g. C{'pyPgSQL.PgSQL'}) @keyword cp_min: the minimum number of connections in pool (default 3) @keyword cp_max: the maximum number of connections in pool (default 5) @keyword cp_noisy: generate informational log messages during operation (default C{False}) @keyword cp_openfun: a callback invoked after every C{connect()} on the underlying DB-API object. The callback is passed a new DB-API connection object. This callback can setup per-connection state such as charset, timezone, etc. @keyword cp_reconnect: detect connections which have failed and reconnect (default C{False}). Failed connections may result in L{ConnectionLost} exceptions, which indicate the query may need to be re-sent. @keyword cp_good_sql: an sql query which should always succeed and change no state (default C{'select 1'}) @keyword cp_reactor: use this reactor instead of the global reactor (added in Twisted 10.2). @type cp_reactor: L{IReactorCore} provider �apilevelNz2.0z'DB API module not DB API 2.0 compliant.� threadsafetyr � z+DB API module not sufficiently thread-safe.� cp_reactor)�reactor�cp_)� threadable� threadpool)� dbapiNamer � namedModule�dbapir% r r! �pop�twisted.internetr5 �_reactor�connargs�connkw�CP_ARGS�setattr�min�max� connections�twisted.pythonr7 r8 � getThreadID�threadID� ThreadPool�callWhenRunning�_start�startID) r r9 r? r@ r5 �arg�cpArgr7 r8 r r r r � s2 # �zConnectionPool.__init__c C s d | _ | �� S r )rL �startr r r r rK � s zConnectionPool._startc C s2 | j s| j�� | j�dd| j�| _d| _ dS dS )z� Start the connection pool. If you are using the reactor normally, this function does *not* need to be called. �during�shutdownTN)�runningr8 rO r> �addSystemEventTrigger� finalClose� shutdownIDr r r r rO � s � �zConnectionPool.startc O �$ t j| j| j| j|g|�R i |��S )a� Execute a function with a database connection and return the result. @param func: A callable object of one argument which will be executed in a thread with a connection from the pool. It will be passed as its first argument a L{Connection} instance (whose interface is mostly identical to that of a connection object for your DB-API module of choice), and its results will be returned as a L{Deferred}. If the method raises an exception the transaction will be rolled back. Otherwise, the transaction will be committed. B{Note} that this function is B{not} run in the main thread: it must be threadsafe. @param args: positional arguments to be passed to func @param kw: keyword arguments to be passed to func @return: a L{Deferred} which will fire the return value of C{func(Transaction(...), *args, **kw)}, or a L{twisted.python.failure.Failure}. )r �deferToThreadPoolr> r8 �_runWithConnection)r �func�args�kwr r r �runWithConnection� s ���z ConnectionPool.runWithConnectionc O sj | � | �}z||g|�R i |��}|�� |W S ty4 z|�� W � ty3 t�d d� Y � w w �Nr )�connectionFactoryr r r r r )r rY rZ r[ �conn�resultr r r rX s ���z!ConnectionPool._runWithConnectionc O rV )a� Interact with the database and return the result. The 'interaction' is a callable object which will be executed in a thread using a pooled connection. It will be passed an L{Transaction} object as an argument (whose interface is identical to that of the database cursor for your DB-API module of choice), and its results will be returned as a L{Deferred}. If running the method raises an exception, the transaction will be rolled back. If the method returns a value, the transaction will be committed. NOTE that the function you pass is *not* run in the main thread: you may have to worry about thread-safety in the function you pass to this if it tries to use non-local objects. @param interaction: a callable object whose first argument is an L{adbapi.Transaction}. @param args: additional positional arguments to be passed to interaction @param kw: keyword arguments to be passed to interaction @return: a Deferred which will fire the return value of C{interaction(Transaction(...), *args, **kw)}, or a L{twisted.python.failure.Failure}. )r rW r> r8 �_runInteraction)r � interactionrZ r[ r r r �runInteraction$ s ���z ConnectionPool.runInteractionc O � | j | jg|�R i |��S )aY Execute an SQL query and return the result. A DB-API cursor which will be invoked with C{cursor.execute(*args, **kw)}. The exact nature of the arguments will depend on the specific flavor of DB-API being used, but the first argument in C{*args} be an SQL statement. The result of a subsequent C{cursor.fetchall()} will be fired to the L{Deferred} which is returned. If either the 'execute' or 'fetchall' methods raise an exception, the transaction will be rolled back and a L{twisted.python.failure.Failure} returned. The C{*args} and C{**kw} arguments will be passed to the DB-API cursor's 'execute' method. @return: a L{Deferred} which will fire the return value of a DB-API cursor's 'fetchall' method, or a L{twisted.python.failure.Failure}. )rc � _runQuery�r rZ r[ r r r �runQueryI s zConnectionPool.runQueryc O rd )aK Execute an SQL query and return L{None}. A DB-API cursor which will be invoked with C{cursor.execute(*args, **kw)}. The exact nature of the arguments will depend on the specific flavor of DB-API being used, but the first argument in C{*args} will be an SQL statement. This method will not attempt to fetch any results from the query and is thus suitable for C{INSERT}, C{DELETE}, and other SQL statements which do not return values. If the 'execute' method raises an exception, the transaction will be rolled back and a L{Failure} returned. The C{*args} and C{*kw} arguments will be passed to the DB-API cursor's 'execute' method. @return: a L{Deferred} which will fire with L{None} or a L{twisted.python.failure.Failure}. )rc � _runOperationrf r r r � runOperation] s zConnectionPool.runOperationc C s@ | j r | j�| j � d| _ | jr| j�| j� d| _| �� dS )zC Close all pool connections and shutdown the pool. N)rU r> �removeSystemEventTriggerrL rT r r r r r r s zConnectionPool.closec C s> d| _ | j�� d| _| j�� D ]}| �|� q| j�� dS )zE This should only be called by the shutdown trigger. NF)rU r8 �stoprR rE �values�_close�clear�r r_ r r r rT ~ s zConnectionPool.finalClosec C sl | � � }| j�|�}|du r4| jrt�d| j� �� | jj| j i | j ��}| j dur/| � |� || j|< |S )a� Return a database connection when one becomes available. This method blocks and should be run in a thread from the internal threadpool. Don't call this method directly from non-threaded code. Using this method outside the external threadpool may exceed the maximum number of connections in the pool. @return: a database connection from the pool. Nzadbapi connecting: ) rH rE �getr r r! r9 r; r# r? r@ �openfun)r �tidr_ r r r r# � s zConnectionPool.connectc C sB | � � }|| j�|�urtd��|dur | �|� | j|= dS dS )a Disconnect a database connection associated with this pool. Note: This function should only be used by the same thread which called L{ConnectionPool.connect}. As with C{connect}, this function is not used in normal non-threaded Twisted code. zwrong connection for threadN)rH rE rp � Exceptionrm )r r_ rr r r r r � s �zConnectionPool.disconnectc C sH | j r t�d| j� �� z|�� W d S ty# t�d d� Y d S w )Nzadbapi closing: zConnection close failed)r r r! r9 r r r ro r r r rm � s �zConnectionPool._closec O s~ | � | �}| �| |�}z||g|�R i |��}|�� |�� |W S ty> z|�� W � ty= t�d d� Y � w w r] )r^ �transactionFactoryr r r r r r )r rb rZ r[ r_ �transr` r r r ra � s ���z ConnectionPool._runInteractionc O s |j |i |�� |�� S r )r �fetchall�r ru rZ r[ r r r re � s zConnectionPool._runQueryc O s |j |i |�� d S r )r rw r r r rh � s z ConnectionPool._runOperationc C s& | j | j| j| j| j| j| j| jd�S )N�r9 rC rD r r r r? r@ rx r r r r � __getstate__� s �zConnectionPool.__getstate__c C s( || _ | j| jg| j�R i | j�� d S r )�__dict__r r9 r? r@ )r �stater r r � __setstate__� s "zConnectionPool.__setstate__)%r r r r �splitrA r rC rD r' rq r r rR r r^ r* rt rU r rK rO r\ rX rc rg ri r rT r# r rm ra re rh ry r| r r r r r. ~ s@ G % r. N) r r= r rF r r rs r r r* r. �__all__r r r r �<module> s 71 bPK v��Z��� � $ __pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dgZdS )z< Twisted Enterprise: Database support for Twisted services. �adbapiN)�__doc__�__all__� r r �=/usr/lib/python3/dist-packages/twisted/enterprise/__init__.py�<module> s PK v��Z.��A A adbapi.pynu �[��� # -*- test-case-name: twisted.test.test_adbapi -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ An asynchronous mapping to U{DB-API 2.0<http://www.python.org/topics/database/DatabaseAPI-2.0.html>}. """ from twisted.internet import threads from twisted.python import log, reflect class ConnectionLost(Exception): """ This exception means that a db connection has been lost. Client code may try again. """ class Connection: """ A wrapper for a DB-API connection instance. The wrapper passes almost everything to the wrapped connection and so has the same API. However, the L{Connection} knows about its pool and also handle reconnecting should when the real connection dies. """ def __init__(self, pool): self._pool = pool self._connection = None self.reconnect() def close(self): # The way adbapi works right now means that closing a connection is # a really bad thing as it leaves a dead connection associated with # a thread in the thread pool. # Really, I think closing a pooled connection should return it to the # pool but that's handled by the runWithConnection method already so, # rather than upsetting anyone by raising an exception, let's ignore # the request pass def rollback(self): if not self._pool.reconnect: self._connection.rollback() return try: self._connection.rollback() curs = self._connection.cursor() curs.execute(self._pool.good_sql) curs.close() self._connection.commit() return except BaseException: log.err(None, "Rollback failed") self._pool.disconnect(self._connection) if self._pool.noisy: log.msg("Connection lost.") raise ConnectionLost() def reconnect(self): if self._connection is not None: self._pool.disconnect(self._connection) self._connection = self._pool.connect() def __getattr__(self, name): return getattr(self._connection, name) class Transaction: """ A lightweight wrapper for a DB-API 'cursor' object. Relays attribute access to the DB cursor. That is, you can call C{execute()}, C{fetchall()}, etc., and they will be called on the underlying DB-API cursor object. Attributes will also be retrieved from there. """ _cursor = None def __init__(self, pool, connection): self._pool = pool self._connection = connection self.reopen() def close(self): _cursor = self._cursor self._cursor = None _cursor.close() def reopen(self): if self._cursor is not None: self.close() try: self._cursor = self._connection.cursor() return except BaseException: if not self._pool.reconnect: raise else: log.err(None, "Cursor creation failed") if self._pool.noisy: log.msg("Connection lost, reconnecting") self.reconnect() self._cursor = self._connection.cursor() def reconnect(self): self._connection.reconnect() self._cursor = None def __getattr__(self, name): return getattr(self._cursor, name) class ConnectionPool: """ Represent a pool of connections to a DB-API 2.0 compliant database. @ivar connectionFactory: factory for connections, default to L{Connection}. @type connectionFactory: any callable. @ivar transactionFactory: factory for transactions, default to L{Transaction}. @type transactionFactory: any callable @ivar shutdownID: L{None} or a handle on the shutdown event trigger which will be used to stop the connection pool workers when the reactor stops. @ivar _reactor: The reactor which will be used to schedule startup and shutdown events. @type _reactor: L{IReactorCore} provider """ CP_ARGS = "min max name noisy openfun reconnect good_sql".split() noisy = False # If true, generate informational log messages min = 3 # Minimum number of connections in pool max = 5 # Maximum number of connections in pool name = None # Name to assign to thread pool for debugging openfun = None # A function to call on new connections reconnect = False # Reconnect when connections fail good_sql = "select 1" # A query which should always succeed running = False # True when the pool is operating connectionFactory = Connection transactionFactory = Transaction # Initialize this to None so it's available in close() even if start() # never runs. shutdownID = None def __init__(self, dbapiName, *connargs, **connkw): """ Create a new L{ConnectionPool}. Any positional or keyword arguments other than those documented here are passed to the DB-API object when connecting. Use these arguments to pass database names, usernames, passwords, etc. @param dbapiName: an import string to use to obtain a DB-API compatible module (e.g. C{'pyPgSQL.PgSQL'}) @keyword cp_min: the minimum number of connections in pool (default 3) @keyword cp_max: the maximum number of connections in pool (default 5) @keyword cp_noisy: generate informational log messages during operation (default C{False}) @keyword cp_openfun: a callback invoked after every C{connect()} on the underlying DB-API object. The callback is passed a new DB-API connection object. This callback can setup per-connection state such as charset, timezone, etc. @keyword cp_reconnect: detect connections which have failed and reconnect (default C{False}). Failed connections may result in L{ConnectionLost} exceptions, which indicate the query may need to be re-sent. @keyword cp_good_sql: an sql query which should always succeed and change no state (default C{'select 1'}) @keyword cp_reactor: use this reactor instead of the global reactor (added in Twisted 10.2). @type cp_reactor: L{IReactorCore} provider """ self.dbapiName = dbapiName self.dbapi = reflect.namedModule(dbapiName) if getattr(self.dbapi, "apilevel", None) != "2.0": log.msg("DB API module not DB API 2.0 compliant.") if getattr(self.dbapi, "threadsafety", 0) < 1: log.msg("DB API module not sufficiently thread-safe.") reactor = connkw.pop("cp_reactor", None) if reactor is None: from twisted.internet import reactor self._reactor = reactor self.connargs = connargs self.connkw = connkw for arg in self.CP_ARGS: cpArg = f"cp_{arg}" if cpArg in connkw: setattr(self, arg, connkw[cpArg]) del connkw[cpArg] self.min = min(self.min, self.max) self.max = max(self.min, self.max) # All connections, hashed on thread id self.connections = {} # These are optional so import them here from twisted.python import threadable, threadpool self.threadID = threadable.getThreadID self.threadpool = threadpool.ThreadPool(self.min, self.max) self.startID = self._reactor.callWhenRunning(self._start) def _start(self): self.startID = None return self.start() def start(self): """ Start the connection pool. If you are using the reactor normally, this function does *not* need to be called. """ if not self.running: self.threadpool.start() self.shutdownID = self._reactor.addSystemEventTrigger( "during", "shutdown", self.finalClose ) self.running = True def runWithConnection(self, func, *args, **kw): """ Execute a function with a database connection and return the result. @param func: A callable object of one argument which will be executed in a thread with a connection from the pool. It will be passed as its first argument a L{Connection} instance (whose interface is mostly identical to that of a connection object for your DB-API module of choice), and its results will be returned as a L{Deferred}. If the method raises an exception the transaction will be rolled back. Otherwise, the transaction will be committed. B{Note} that this function is B{not} run in the main thread: it must be threadsafe. @param args: positional arguments to be passed to func @param kw: keyword arguments to be passed to func @return: a L{Deferred} which will fire the return value of C{func(Transaction(...), *args, **kw)}, or a L{twisted.python.failure.Failure}. """ return threads.deferToThreadPool( self._reactor, self.threadpool, self._runWithConnection, func, *args, **kw ) def _runWithConnection(self, func, *args, **kw): conn = self.connectionFactory(self) try: result = func(conn, *args, **kw) conn.commit() return result except BaseException: try: conn.rollback() except BaseException: log.err(None, "Rollback failed") raise def runInteraction(self, interaction, *args, **kw): """ Interact with the database and return the result. The 'interaction' is a callable object which will be executed in a thread using a pooled connection. It will be passed an L{Transaction} object as an argument (whose interface is identical to that of the database cursor for your DB-API module of choice), and its results will be returned as a L{Deferred}. If running the method raises an exception, the transaction will be rolled back. If the method returns a value, the transaction will be committed. NOTE that the function you pass is *not* run in the main thread: you may have to worry about thread-safety in the function you pass to this if it tries to use non-local objects. @param interaction: a callable object whose first argument is an L{adbapi.Transaction}. @param args: additional positional arguments to be passed to interaction @param kw: keyword arguments to be passed to interaction @return: a Deferred which will fire the return value of C{interaction(Transaction(...), *args, **kw)}, or a L{twisted.python.failure.Failure}. """ return threads.deferToThreadPool( self._reactor, self.threadpool, self._runInteraction, interaction, *args, **kw, ) def runQuery(self, *args, **kw): """ Execute an SQL query and return the result. A DB-API cursor which will be invoked with C{cursor.execute(*args, **kw)}. The exact nature of the arguments will depend on the specific flavor of DB-API being used, but the first argument in C{*args} be an SQL statement. The result of a subsequent C{cursor.fetchall()} will be fired to the L{Deferred} which is returned. If either the 'execute' or 'fetchall' methods raise an exception, the transaction will be rolled back and a L{twisted.python.failure.Failure} returned. The C{*args} and C{**kw} arguments will be passed to the DB-API cursor's 'execute' method. @return: a L{Deferred} which will fire the return value of a DB-API cursor's 'fetchall' method, or a L{twisted.python.failure.Failure}. """ return self.runInteraction(self._runQuery, *args, **kw) def runOperation(self, *args, **kw): """ Execute an SQL query and return L{None}. A DB-API cursor which will be invoked with C{cursor.execute(*args, **kw)}. The exact nature of the arguments will depend on the specific flavor of DB-API being used, but the first argument in C{*args} will be an SQL statement. This method will not attempt to fetch any results from the query and is thus suitable for C{INSERT}, C{DELETE}, and other SQL statements which do not return values. If the 'execute' method raises an exception, the transaction will be rolled back and a L{Failure} returned. The C{*args} and C{*kw} arguments will be passed to the DB-API cursor's 'execute' method. @return: a L{Deferred} which will fire with L{None} or a L{twisted.python.failure.Failure}. """ return self.runInteraction(self._runOperation, *args, **kw) def close(self): """ Close all pool connections and shutdown the pool. """ if self.shutdownID: self._reactor.removeSystemEventTrigger(self.shutdownID) self.shutdownID = None if self.startID: self._reactor.removeSystemEventTrigger(self.startID) self.startID = None self.finalClose() def finalClose(self): """ This should only be called by the shutdown trigger. """ self.shutdownID = None self.threadpool.stop() self.running = False for conn in self.connections.values(): self._close(conn) self.connections.clear() def connect(self): """ Return a database connection when one becomes available. This method blocks and should be run in a thread from the internal threadpool. Don't call this method directly from non-threaded code. Using this method outside the external threadpool may exceed the maximum number of connections in the pool. @return: a database connection from the pool. """ tid = self.threadID() conn = self.connections.get(tid) if conn is None: if self.noisy: log.msg(f"adbapi connecting: {self.dbapiName}") conn = self.dbapi.connect(*self.connargs, **self.connkw) if self.openfun is not None: self.openfun(conn) self.connections[tid] = conn return conn def disconnect(self, conn): """ Disconnect a database connection associated with this pool. Note: This function should only be used by the same thread which called L{ConnectionPool.connect}. As with C{connect}, this function is not used in normal non-threaded Twisted code. """ tid = self.threadID() if conn is not self.connections.get(tid): raise Exception("wrong connection for thread") if conn is not None: self._close(conn) del self.connections[tid] def _close(self, conn): if self.noisy: log.msg(f"adbapi closing: {self.dbapiName}") try: conn.close() except BaseException: log.err(None, "Connection close failed") def _runInteraction(self, interaction, *args, **kw): conn = self.connectionFactory(self) trans = self.transactionFactory(self, conn) try: result = interaction(trans, *args, **kw) trans.close() conn.commit() return result except BaseException: try: conn.rollback() except BaseException: log.err(None, "Rollback failed") raise def _runQuery(self, trans, *args, **kw): trans.execute(*args, **kw) return trans.fetchall() def _runOperation(self, trans, *args, **kw): trans.execute(*args, **kw) def __getstate__(self): return { "dbapiName": self.dbapiName, "min": self.min, "max": self.max, "noisy": self.noisy, "reconnect": self.reconnect, "good_sql": self.good_sql, "connargs": self.connargs, "connkw": self.connkw, } def __setstate__(self, state): self.__dict__ = state self.__init__(self.dbapiName, *self.connargs, **self.connkw) __all__ = ["Transaction", "ConnectionPool"] PK v��Z�i,�� � __init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted Enterprise: Database support for Twisted services. """ __all__ = ["adbapi"] PK v��ZR��> > " __pycache__/adbapi.cpython-310.pycnu �[��� PK v��Z��� � $ V> __pycache__/__init__.cpython-310.pycnu �[��� PK v��Z.��A A �? adbapi.pynu �[��� PK v��Z�i,�� � � __init__.pynu �[��� PK Z Ɂ
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.03 |
proxy
|
phpinfo
|
Settings