File Manager

Hackfut Security File Manager

Current Path: /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine

opt / alt / python27 / lib64 / python2.7 / site-packages / sqlalchemy / engine /

📁 ..
📄 __init__.py(18.48 KB)
📄 __init__.pyc(19.05 KB)
📄 __init__.pyo(19.05 KB)
📄 base.py(80.14 KB)
📄 base.pyc(76.01 KB)
📄 base.pyo(75.59 KB)
📄 default.py(38.6 KB)
📄 default.pyc(34.23 KB)
📄 default.pyo(34.18 KB)
📄 interfaces.py(40.12 KB)
📄 interfaces.pyc(44.37 KB)
📄 interfaces.pyo(44.37 KB)
📄 reflection.py(30.1 KB)
📄 reflection.pyc(27.19 KB)
📄 reflection.pyo(27.19 KB)
📄 result.py(50.37 KB)
📄 result.pyc(49.12 KB)
📄 result.pyo(49.12 KB)
📄 strategies.py(9.24 KB)
📄 strategies.pyc(10.51 KB)
📄 strategies.pyo(10.51 KB)
📄 threadlocal.py(4.09 KB)
📄 threadlocal.pyc(6.14 KB)
📄 threadlocal.pyo(6.14 KB)
📄 url.py(8.27 KB)
📄 url.pyc(9.98 KB)
📄 url.pyo(9.98 KB)
📄 util.py(2.28 KB)
📄 util.pyc(2.11 KB)
📄 util.pyo(2.11 KB)

Editing: threadlocal.py

# engine/threadlocal.py
# Copyright (C) 2005-2017 the SQLAlchemy authors and contributors
# <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php

"""Provides a thread-local transactional wrapper around the root Engine class.

The ``threadlocal`` module is invoked when using the
``strategy="threadlocal"`` flag with :func:`~sqlalchemy.engine.create_engine`.
This module is semi-private and is invoked automatically when the threadlocal
engine strategy is used.
"""

from .. import util
from . import base
import weakref

class TLConnection(base.Connection):

def __init__(self, *arg, **kw):
        super(TLConnection, self).__init__(*arg, **kw)
        self.__opencount = 0

def _increment_connect(self):
        self.__opencount += 1
        return self

def close(self):
        if self.__opencount == 1:
            base.Connection.close(self)
        self.__opencount -= 1

def _force_close(self):
        self.__opencount = 0
        base.Connection.close(self)

class TLEngine(base.Engine):
    """An Engine that includes support for thread-local managed
    transactions.

"""
    _tl_connection_cls = TLConnection

def __init__(self, *args, **kwargs):
        super(TLEngine, self).__init__(*args, **kwargs)
        self._connections = util.threading.local()

def contextual_connect(self, **kw):
        if not hasattr(self._connections, 'conn'):
            connection = None
        else:
            connection = self._connections.conn()

if connection is None or connection.closed:
            # guards against pool-level reapers, if desired.
            # or not connection.connection.is_valid:
            connection = self._tl_connection_cls(
                self,
                self._wrap_pool_connect(
                    self.pool.connect, connection),
                **kw)
            self._connections.conn = weakref.ref(connection)

return connection._increment_connect()

def begin_twophase(self, xid=None):
        if not hasattr(self._connections, 'trans'):
            self._connections.trans = []
        self._connections.trans.append(
            self.contextual_connect().begin_twophase(xid=xid))
        return self

def begin_nested(self):
        if not hasattr(self._connections, 'trans'):
            self._connections.trans = []
        self._connections.trans.append(
            self.contextual_connect().begin_nested())
        return self

def begin(self):
        if not hasattr(self._connections, 'trans'):
            self._connections.trans = []
        self._connections.trans.append(self.contextual_connect().begin())
        return self

def __enter__(self):
        return self

def __exit__(self, type, value, traceback):
        if type is None:
            self.commit()
        else:
            self.rollback()

def prepare(self):
        if not hasattr(self._connections, 'trans') or \
                not self._connections.trans:
            return
        self._connections.trans[-1].prepare()

def commit(self):
        if not hasattr(self._connections, 'trans') or \
                not self._connections.trans:
            return
        trans = self._connections.trans.pop(-1)
        trans.commit()

def rollback(self):
        if not hasattr(self._connections, 'trans') or \
                not self._connections.trans:
            return
        trans = self._connections.trans.pop(-1)
        trans.rollback()

def dispose(self):
        self._connections = util.threading.local()
        super(TLEngine, self).dispose()

@property
    def closed(self):
        return not hasattr(self._connections, 'conn') or \
            self._connections.conn() is None or \
            self._connections.conn().closed

def close(self):
        if not self.closed:
            self.contextual_connect().close()
            connection = self._connections.conn()
            connection._force_close()
            del self._connections.conn
            self._connections.trans = []

def __repr__(self):
        return 'TLEngine(%r)' % self.url

Hackfut Security File Manager

Editing: threadlocal.py

Upload File

Create Folder