sqlalchemy-iris 0.14.0__tar.gz → 0.14.1b1__tar.gz

{sqlalchemy_iris-0.14.0/sqlalchemy_iris.egg-info → sqlalchemy_iris-0.14.1b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-iris
-Version: 0.14.0
+Version: 0.14.1b1
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev

{sqlalchemy_iris-0.14.0 → sqlalchemy_iris-0.14.1b1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = sqlalchemy-iris
-version = 0.14.0
+version = 0.14.1b1
 description = InterSystems IRIS for SQLAlchemy
 long_description = file: README.md
 url = https://github.com/caretdev/sqlalchemy-iris

{sqlalchemy_iris-0.14.0 → sqlalchemy_iris-0.14.1b1}/sqlalchemy_iris/base.py

@@ -91,7 +91,6 @@ from .types import IRISTime
 from .types import IRISTimeStamp
 from .types import IRISDate
 from .types import IRISDateTime
-from .types import IRISUniqueIdentifier
 from .types import IRISListBuild  # noqa
 from .types import IRISVector  # noqa
 
@@ -819,8 +818,10 @@ colspecs = {
     sqltypes.DateTime: IRISDateTime,
     sqltypes.TIMESTAMP: IRISTimeStamp,
     sqltypes.Time: IRISTime,
-    sqltypes.UUID: IRISUniqueIdentifier,
 }
+if sqlalchemy_version.startswith("2."):
+    from .types import IRISUniqueIdentifier
+    colspecs[sqltypes.UUID] = IRISUniqueIdentifier
 
 
 class IRISExact(ReturnTypeFromArgs):

{sqlalchemy_iris-0.14.0 → sqlalchemy_iris-0.14.1b1}/sqlalchemy_iris/types.py

@@ -2,9 +2,10 @@ import datetime
 from decimal import Decimal
 from sqlalchemy import func, text
 from sqlalchemy.sql import sqltypes
-from sqlalchemy.types import UserDefinedType, Float
+from sqlalchemy.types import UserDefinedType
 from uuid import UUID as _python_UUID
 from intersystems_iris import IRISList
+from sqlalchemy import __version__ as sqlalchemy_version
 
 HOROLOG_ORDINAL = datetime.date(1840, 12, 31).toordinal()
 
@@ -134,73 +135,79 @@ class IRISTime(sqltypes.DateTime):
         return process
 
 
-class IRISUniqueIdentifier(sqltypes.Uuid):
-    def literal_processor(self, dialect):
-        if not self.as_uuid:
+if sqlalchemy_version.startswith("2."):
 
-            def process(value):
-                return f"""'{value.replace("'", "''")}'"""
-
-            return process
-        else:
-
-            def process(value):
-                return f"""'{str(value).replace("'", "''")}'"""
-
-            return process
-
-    def bind_processor(self, dialect):
-        character_based_uuid = not dialect.supports_native_uuid or not self.native_uuid
-
-        if character_based_uuid:
-            if self.as_uuid:
+    class IRISUniqueIdentifier(sqltypes.Uuid):
+        def literal_processor(self, dialect):
+            if not self.as_uuid:
 
                 def process(value):
-                    if value is not None:
-                        value = str(value)
-                    return value
+                    return f"""'{value.replace("'", "''")}'"""
 
                 return process
             else:
 
                 def process(value):
-                    return value
+                    return f"""'{str(value).replace("'", "''")}'"""
 
                 return process
-        else:
-            return None
 
-    def result_processor(self, dialect, coltype):
-        character_based_uuid = not dialect.supports_native_uuid or not self.native_uuid
+        def bind_processor(self, dialect):
+            character_based_uuid = (
+                not dialect.supports_native_uuid or not self.native_uuid
+            )
 
-        if character_based_uuid:
-            if self.as_uuid:
+            if character_based_uuid:
+                if self.as_uuid:
 
-                def process(value):
-                    if value and not isinstance(value, _python_UUID):
-                        value = _python_UUID(value)
-                    return value
+                    def process(value):
+                        if value is not None:
+                            value = str(value)
+                        return value
 
-                return process
+                    return process
+                else:
+
+                    def process(value):
+                        return value
+
+                    return process
             else:
+                return None
 
-                def process(value):
-                    if value and isinstance(value, _python_UUID):
-                        value = str(value)
-                    return value
+        def result_processor(self, dialect, coltype):
+            character_based_uuid = (
+                not dialect.supports_native_uuid or not self.native_uuid
+            )
 
-                return process
-        else:
-            if not self.as_uuid:
+            if character_based_uuid:
+                if self.as_uuid:
 
-                def process(value):
-                    if value and isinstance(value, _python_UUID):
-                        value = str(value)
-                    return value
+                    def process(value):
+                        if value and not isinstance(value, _python_UUID):
+                            value = _python_UUID(value)
+                        return value
 
-                return process
+                    return process
+                else:
+
+                    def process(value):
+                        if value and isinstance(value, _python_UUID):
+                            value = str(value)
+                        return value
+
+                    return process
             else:
-                return None
+                if not self.as_uuid:
+
+                    def process(value):
+                        if value and isinstance(value, _python_UUID):
+                            value = str(value)
+                        return value
+
+                    return process
+                else:
+                    return None
 
 
 class IRISListBuild(UserDefinedType):
@@ -267,9 +274,7 @@ class IRISVector(UserDefinedType):
         item_type_server = (
             "decimal"
             if self.item_type is float
-            else "float"
-            if self.item_type is Decimal
-            else "int"
+            else "float" if self.item_type is Decimal else "int"
         )
         self.item_type_server = item_type_server
 
@@ -304,19 +309,21 @@ class IRISVector(UserDefinedType):
         #     return self.func('vector_l2', other)
 
         def max_inner_product(self, other):
-            return self.func('vector_dot_product', other)
+            return self.func("vector_dot_product", other)
 
         def cosine_distance(self, other):
-            return self.func('vector_cosine', other)
+            return self.func("vector_cosine", other)
 
         def cosine(self, other):
-            return (1 - self.func('vector_cosine', other))
+            return 1 - self.func("vector_cosine", other)
 
         def func(self, funcname: str, other):
             if not isinstance(other, list) and not isinstance(other, tuple):
                 raise ValueError("expected list or tuple, got '%s'" % type(other))
             othervalue = f"[{','.join([str(v) for v in other])}]"
-            return getattr(func, funcname)(self, func.to_vector(othervalue, text(self.type.item_type_server)))
+            return getattr(func, funcname)(
+                self, func.to_vector(othervalue, text(self.type.item_type_server))
+            )
 
 
 class BIT(sqltypes.TypeEngine):

{sqlalchemy_iris-0.14.0 → sqlalchemy_iris-0.14.1b1/sqlalchemy_iris.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-iris
-Version: 0.14.0
+Version: 0.14.1b1
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev

{sqlalchemy_iris-0.14.0 → sqlalchemy_iris-0.14.1b1}/tests/test_suite.py

@@ -4,9 +4,6 @@ from sqlalchemy.testing.suite import FetchLimitOffsetTest as _FetchLimitOffsetTe
 from sqlalchemy.testing.suite import CompoundSelectTest as _CompoundSelectTest
 from sqlalchemy.testing.suite import CTETest as _CTETest
 from sqlalchemy.testing.suite import DifficultParametersTest as _DifficultParametersTest
-from sqlalchemy.testing.suite import (
-    BizarroCharacterFKResolutionTest as _BizarroCharacterFKResolutionTest,
-)
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing.assertions import eq_
 from sqlalchemy.testing import config
@@ -26,6 +23,8 @@ import pytest
 
 from sqlalchemy.testing.suite import *  # noqa
 
+from sqlalchemy import __version__ as sqlalchemy_version
+
 
 class CompoundSelectTest(_CompoundSelectTest):
     @pytest.mark.skip()
@@ -270,166 +269,175 @@ class IRISEnumTest(fixtures.TablesTest):
         )
 
 
-class BizarroCharacterFKResolutionTest(_BizarroCharacterFKResolutionTest):
-    @testing.combinations(
-        ("id",), ("(3)",), ("col%p",), ("[brack]",), argnames="columnname"
-    )
-    @testing.variation("use_composite", [True, False])
-    @testing.combinations(
-        ("plain",),
-        # ("(2)",), not in IRIS
-        ("per % cent",),
-        ("[brackets]",),
-        argnames="tablename",
+if sqlalchemy_version.startswith("2."):
+    from sqlalchemy.testing.suite import (
+        BizarroCharacterFKResolutionTest as _BizarroCharacterFKResolutionTest,
     )
-    def test_fk_ref(self, connection, metadata, use_composite, tablename, columnname):
-        super().test_fk_ref(connection, metadata, use_composite, tablename, columnname)
-
 
-class IRISListBuildTest(fixtures.TablesTest):
-    __backend__ = True
-
-    @classmethod
-    def define_tables(cls, metadata):
-        Table(
-            "data",
-            metadata,
-            Column("val", IRISListBuild(10, float)),
+    class BizarroCharacterFKResolutionTest(_BizarroCharacterFKResolutionTest):
+        @testing.combinations(
+            ("id",), ("(3)",), ("col%p",), ("[brack]",), argnames="columnname"
+        )
+        @testing.variation("use_composite", [True, False])
+        @testing.combinations(
+            ("plain",),
+            # ("(2)",), not in IRIS
+            ("per % cent",),
+            ("[brackets]",),
+            argnames="tablename",
         )
+        def test_fk_ref(
+            self, connection, metadata, use_composite, tablename, columnname
+        ):
+            super().test_fk_ref(
+                connection, metadata, use_composite, tablename, columnname
+            )
 
-    @classmethod
-    def fixtures(cls):
-        return dict(
-            data=(
-                ("val",),
-                ([1.0] * 50,),
-                ([1.23] * 50,),
-                ([i for i in range(0, 50)],),
-                (None,),
+    class IRISListBuildTest(fixtures.TablesTest):
+        __backend__ = True
+
+        @classmethod
+        def define_tables(cls, metadata):
+            Table(
+                "data",
+                metadata,
+                Column("val", IRISListBuild(10, float)),
             )
-        )
 
-    def _assert_result(self, select, result):
-        with config.db.connect() as conn:
-            eq_(conn.execute(select).fetchall(), result)
+        @classmethod
+        def fixtures(cls):
+            return dict(
+                data=(
+                    ("val",),
+                    ([1.0] * 50,),
+                    ([1.23] * 50,),
+                    ([i for i in range(0, 50)],),
+                    (None,),
+                )
+            )
 
-    def test_listbuild(self):
-        self._assert_result(
-            select(self.tables.data),
-            [
-                ([1.0] * 50,),
-                ([1.23] * 50,),
-                ([i for i in range(0, 50)],),
-                (None,),
-            ],
-        )
-        self._assert_result(
-            select(self.tables.data).where(self.tables.data.c.val == [1.0] * 50),
-            [
-                ([1.0] * 50,),
-            ],
-        )
+        def _assert_result(self, select, result):
+            with config.db.connect() as conn:
+                eq_(conn.execute(select).fetchall(), result)
 
-        self._assert_result(
-            select(
-                self.tables.data,
-                self.tables.data.c.val.func("$listsame", [1.0] * 50).label("same"),
-            ).limit(1),
-            [
-                ([1.0] * 50, 1),
-            ],
-        )
+        def test_listbuild(self):
+            self._assert_result(
+                select(self.tables.data),
+                [
+                    ([1.0] * 50,),
+                    ([1.23] * 50,),
+                    ([i for i in range(0, 50)],),
+                    (None,),
+                ],
+            )
+            self._assert_result(
+                select(self.tables.data).where(self.tables.data.c.val == [1.0] * 50),
+                [
+                    ([1.0] * 50,),
+                ],
+            )
 
+            self._assert_result(
+                select(
+                    self.tables.data,
+                    self.tables.data.c.val.func("$listsame", [1.0] * 50).label("same"),
+                ).limit(1),
+                [
+                    ([1.0] * 50, 1),
+                ],
+            )
 
-class IRISVectorTest(fixtures.TablesTest):
-    __backend__ = True
+    class IRISVectorTest(fixtures.TablesTest):
+        __backend__ = True
 
-    __requires__ = ("iris_vector",)
+        __requires__ = ("iris_vector",)
 
-    @classmethod
-    def define_tables(cls, metadata):
-        Table(
-            "data",
-            metadata,
-            Column("id", INTEGER),
-            Column("emb", IRISVector(3, float)),
-        )
+        @classmethod
+        def define_tables(cls, metadata):
+            Table(
+                "data",
+                metadata,
+                Column("id", INTEGER),
+                Column("emb", IRISVector(3, float)),
+            )
 
-    @classmethod
-    def fixtures(cls):
-        return dict(
-            data=(
-                (
-                    "id",
-                    "emb",
-                ),
-                (
-                    1,
-                    [1, 1, 1],
-                ),
-                (
-                    2,
-                    [2, 2, 2],
-                ),
-                (
-                    3,
-                    [1, 1, 2],
-                ),
+        @classmethod
+        def fixtures(cls):
+            return dict(
+                data=(
+                    (
+                        "id",
+                        "emb",
+                    ),
+                    (
+                        1,
+                        [1, 1, 1],
+                    ),
+                    (
+                        2,
+                        [2, 2, 2],
+                    ),
+                    (
+                        3,
+                        [1, 1, 2],
+                    ),
+                )
             )
-        )
 
-    def _assert_result(self, select, result):
-        with config.db.connect() as conn:
-            eq_(conn.execute(select).fetchall(), result)
+        def _assert_result(self, select, result):
+            with config.db.connect() as conn:
+                eq_(conn.execute(select).fetchall(), result)
 
-    def test_vector(self):
-        self._assert_result(
-            select(self.tables.data.c.emb),
-            [
-                ([1, 1, 1],),
-                ([2, 2, 2],),
-                ([1, 1, 2],),
-            ],
-        )
-        self._assert_result(
-            select(self.tables.data.c.id).where(self.tables.data.c.emb == [2, 2, 2]),
-            [
-                (2,),
-            ],
-        )
+        def test_vector(self):
+            self._assert_result(
+                select(self.tables.data.c.emb),
+                [
+                    ([1, 1, 1],),
+                    ([2, 2, 2],),
+                    ([1, 1, 2],),
+                ],
+            )
+            self._assert_result(
+                select(self.tables.data.c.id).where(
+                    self.tables.data.c.emb == [2, 2, 2]
+                ),
+                [
+                    (2,),
+                ],
+            )
 
-    def test_cosine(self):
-        self._assert_result(
-            select(
-                self.tables.data.c.id,
-            ).order_by(self.tables.data.c.emb.cosine([1, 1, 1])),
-            [
-                (1,),
-                (2,),
-                (3,),
-            ],
-        )
+        def test_cosine(self):
+            self._assert_result(
+                select(
+                    self.tables.data.c.id,
+                ).order_by(self.tables.data.c.emb.cosine([1, 1, 1])),
+                [
+                    (1,),
+                    (2,),
+                    (3,),
+                ],
+            )
 
-    def test_cosine_distance(self):
-        self._assert_result(
-            select(
-                self.tables.data.c.id,
-            ).order_by(1 - self.tables.data.c.emb.cosine_distance([1, 1, 1])),
-            [
-                (1,),
-                (2,),
-                (3,),
-            ],
-        )
+        def test_cosine_distance(self):
+            self._assert_result(
+                select(
+                    self.tables.data.c.id,
+                ).order_by(1 - self.tables.data.c.emb.cosine_distance([1, 1, 1])),
+                [
+                    (1,),
+                    (2,),
+                    (3,),
+                ],
+            )
 
-    def test_max_inner_product(self):
-        self._assert_result(
-            select(
-                self.tables.data.c.id,
-            ).order_by(self.tables.data.c.emb.max_inner_product([1, 1, 1])),
-            [
-                (1,),
-                (3,),
-                (2,),
-            ],
-        )
+        def test_max_inner_product(self):
+            self._assert_result(
+                select(
+                    self.tables.data.c.id,
+                ).order_by(self.tables.data.c.emb.max_inner_product([1, 1, 1])),
+                [
+                    (1,),
+                    (3,),
+                    (2,),
+                ],
+            )