FM / engine

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

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

Name	Size	Mode	Actions
base.py	84126	0644	edit dl rm
base.pyc	79309	0644	edit dl rm
base.pyo	78882	0644	edit dl rm
default.py	51401	0644	edit dl rm
default.pyc	43608	0644	edit dl rm
default.pyo	43556	0644	edit dl rm
interfaces.py	42397	0644	edit dl rm
interfaces.pyc	46807	0644	edit dl rm
interfaces.pyo	46807	0644	edit dl rm
reflection.py	33343	0644	edit dl rm
reflection.pyc	29822	0644	edit dl rm
reflection.pyo	29822	0644	edit dl rm
result.py	52615	0644	edit dl rm
result.pyc	50588	0644	edit dl rm
result.pyo	50588	0644	edit dl rm
strategies.py	9750	0644	edit dl rm
strategies.pyc	11146	0644	edit dl rm
strategies.pyo	11146	0644	edit dl rm
threadlocal.py	4746	0644	edit dl rm
threadlocal.pyc	6834	0644	edit dl rm
threadlocal.pyo	6834	0644	edit dl rm
url.py	9411	0644	edit dl rm
url.pyc	10939	0644	edit dl rm
url.pyo	10939	0644	edit dl rm
util.py	2421	0644	edit dl rm
util.pyc	2164	0644	edit dl rm
util.pyo	2164	0644	edit dl rm
__init__.py	21671	0644	edit dl rm
__init__.pyc	22167	0644	edit dl rm
__init__.pyo	22167	0644	edit dl rm

Edit: /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/threadlocal.py (4746B)

# engine/threadlocal.py
# Copyright (C) 2005-2019 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.
"""

import weakref

from . import base
from .. import util

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

@util.deprecated(
        "1.3",
        "The 'threadlocal' engine strategy is deprecated, and will be "
        "removed in a future release.  The strategy is no longer relevant "
        "to modern usage patterns (including that of the ORM "
        ":class:`.Session` object) which make use of a :class:`.Connection` "
        "object in order to invoke statements.",
    )
    def __init__(self, *args, **kwargs):
        super(TLEngine, self).__init__(*args, **kwargs)
        self._connections = util.threading.local()

def contextual_connect(self, **kw):
        return self._contextual_connect(**kw)

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

cmd: