Remove threadlocal engine strategy, engine strategies pool threadlocal

The "threadlocal" execution strategy, deprecated in 1.3, has been
removed for 1.4, as well as the concept of "engine strategies" and the
``Engine.contextual_connect`` method.  The "strategy='mock'" keyword
argument is still accepted for now with a deprecation warning; use
:func:`.create_mock_engine` instead for this use case.

Fixes: #4632
Change-Id: I8a351f9fa1f7dfa2a56eec1cd2d1a4b9d65765a2
(cherry picked from commit b368c49b44c5716d93c7428ab22b6761c6ca7cf5)

1 files changed, 0 insertions, 160 deletions

diff --git a/lib/sqlalchemy/engine/threadlocal.py b/lib/sqlalchemy/engine/threadlocal.py
deleted file mode 100644
index 8e8663ccc..000000000
--- a/lib/sqlalchemy/engine/threadlocal.py
+++ /dev/null
@@ -1,160 +0,0 @@
-# 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