Replace c extension with cython versions.workflow_test_cython

Re-implement c version immutabledict / processors / resultproxy / utils with cython.
Performance is in general in par or better than the c version
Added a collection module that has cython version of OrderedSet and IdentitySet

Added a new test/perf file to compare the implementations.
Run ``python test/perf/compiled_extensions.py all`` to execute the comparison test.

See results here: https://docs.google.com/document/d/1nOcDGojHRtXEkuy4vNXcW_XOJd9gqKhSeALGG3kYr6A/edit?usp=sharing

Fixes: #7256
Change-Id: I2930ef1894b5048210384728118e586e813f6a76
Signed-off-by: Federico Caselli <cfederico87@gmail.com>

1 files changed, 0 insertions, 132 deletions

diff --git a/lib/sqlalchemy/processors.py b/lib/sqlalchemy/processors.py
deleted file mode 100644
index 156005c6a..000000000
--- a/lib/sqlalchemy/processors.py
+++ /dev/null
@@ -1,132 +0,0 @@
-# sqlalchemy/processors.py
-# Copyright (C) 2010-2021 the SQLAlchemy authors and contributors
-# <see AUTHORS file>
-# Copyright (C) 2010 Gaetan de Menten gdementen@gmail.com
-#
-# This module is part of SQLAlchemy and is released under
-# the MIT License: https://www.opensource.org/licenses/mit-license.php
-
-"""defines generic type conversion functions, as used in bind and result
-processors.
-
-They all share one common characteristic: None is passed through unchanged.
-
-"""
-
-import datetime
-import re
-
-from . import util
-
-
-def str_to_datetime_processor_factory(regexp, type_):
-    rmatch = regexp.match
-    # Even on python2.6 datetime.strptime is both slower than this code
-    # and it does not support microseconds.
-    has_named_groups = bool(regexp.groupindex)
-
-    def process(value):
-        if value is None:
-            return None
-        else:
-            try:
-                m = rmatch(value)
-            except TypeError as err:
-                util.raise_(
-                    ValueError(
-                        "Couldn't parse %s string '%r' "
-                        "- value is not a string." % (type_.__name__, value)
-                    ),
-                    from_=err,
-                )
-            if m is None:
-                raise ValueError(
-                    "Couldn't parse %s string: "
-                    "'%s'" % (type_.__name__, value)
-                )
-            if has_named_groups:
-                groups = m.groupdict(0)
-                return type_(
-                    **dict(
-                        list(
-                            zip(
-                                iter(groups.keys()),
-                                list(map(int, iter(groups.values()))),
-                            )
-                        )
-                    )
-                )
-            else:
-                return type_(*list(map(int, m.groups(0))))
-
-    return process
-
-
-def py_fallback():
-    def to_decimal_processor_factory(target_class, scale):
-        fstring = "%%.%df" % scale
-
-        def process(value):
-            if value is None:
-                return None
-            else:
-                return target_class(fstring % value)
-
-        return process
-
-    def to_float(value):  # noqa
-        if value is None:
-            return None
-        else:
-            return float(value)
-
-    def to_str(value):  # noqa
-        if value is None:
-            return None
-        else:
-            return str(value)
-
-    def int_to_boolean(value):  # noqa
-        if value is None:
-            return None
-        else:
-            return bool(value)
-
-    DATETIME_RE = re.compile(
-        r"(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)(?:\.(\d+))?"
-    )
-    TIME_RE = re.compile(r"(\d+):(\d+):(\d+)(?:\.(\d+))?")
-    DATE_RE = re.compile(r"(\d+)-(\d+)-(\d+)")
-
-    str_to_datetime = str_to_datetime_processor_factory(  # noqa
-        DATETIME_RE, datetime.datetime
-    )
-    str_to_time = str_to_datetime_processor_factory(  # noqa
-        TIME_RE, datetime.time
-    )  # noqa
-    str_to_date = str_to_datetime_processor_factory(  # noqa
-        DATE_RE, datetime.date
-    )  # noqa
-    return locals()
-
-
-try:
-    from sqlalchemy.cprocessors import DecimalResultProcessor  # noqa
-    from sqlalchemy.cprocessors import int_to_boolean  # noqa
-    from sqlalchemy.cprocessors import str_to_date  # noqa
-    from sqlalchemy.cprocessors import str_to_datetime  # noqa
-    from sqlalchemy.cprocessors import str_to_time  # noqa
-    from sqlalchemy.cprocessors import to_float  # noqa
-    from sqlalchemy.cprocessors import to_str  # noqa
-
-    def to_decimal_processor_factory(target_class, scale):
-        # Note that the scale argument is not taken into account for integer
-        # values in the C implementation while it is in the Python one.
-        # For example, the Python implementation might return
-        # Decimal('5.00000') whereas the C implementation will
-        # return Decimal('5'). These are equivalent of course.
-        return DecimalResultProcessor(target_class, "%%.%df" % scale).process
-
-
-except ImportError:
-    globals().update(py_fallback())