sqlalchemy-iris 0.15.5__py3-none-any.whl → 0.15.6b1__py3-none-any.whl

intersystems_iris/dbapi/_Column.py

@@ -54,3 +54,6 @@ class _Column(intersystems_iris.dbapi._Descriptor._Descriptor):
                           self.isKeyColumn,
                           self.isRowId]
         return _Column(self.name, self.type, self.precision, self.scale, self.nullable, self.label, self.tableName, self.schema, self.catalog, additionalData, self.slotPosition)
+
+    def __repr__(self) -> str:
+        return f"<Column name='{self.name}' type='{self.type}'>"

intersystems_iris/dbapi/_DBAPI.py

@@ -14,7 +14,7 @@ from ._ResultSetRow import _ResultSetRow
 import intersystems_iris.dbapi._ParameterCollection
 import intersystems_iris.dbapi.preparser._PreParser
 from intersystems_iris.dbapi._Parameter import ParameterMode
-from intersystems_iris.dbapi.preparser._PreParser import StatementType, MultiValuesInsert
+from intersystems_iris.dbapi.preparser._PreParser import StatementType, MultiValuesInsert, InsertWithReturning
 from intersystems_iris._IRISConnection import Feature
 from intersystems_iris._InStream import _InStream
 from intersystems_iris.dbapi._IRISStream import (
@@ -252,6 +252,11 @@ class _BaseCursor:
         self._cleanup()
         try:
             self._preparse()
+        except InsertWithReturning as ex:
+            ids = intersystems_iris._ListWriter._ListWriter()
+            self.execute(ex.insert_query, params)
+            ids._set(self.lastrowid)
+            return self.execute(ex.select_query, bytes(ids._get_buffer()))
         except MultiValuesInsert as ex:
             # convert to executemany
             params = params or ex.params
@@ -269,6 +274,7 @@ class _BaseCursor:
 
         self._execute()
         return self._rowcount
+        # return self.execute(returning_query)
 
     def add_batch(self):
         self._is_alive()
@@ -321,7 +327,17 @@ class _BaseCursor:
         self._cleanup()
         self._is_batch_update = True
 
-        self._preparse()
+        try:
+            self._preparse()
+        except InsertWithReturning as ex:
+            ids = intersystems_iris._ListWriter._ListWriter()
+            for params in seq_of_params:
+                self.execute(ex.insert_query, params)
+                ids._set(self.lastrowid)
+            self.execute(ex.select_query, bytes(ids._get_buffer()))
+            raise
+        except Exception:
+            raise
         self._prepare()
 
         for row_num, param_row in enumerate(seq_of_params):
@@ -389,6 +405,8 @@ class _BaseCursor:
         )
         try:
             pOut = parser.PreParse(self.statement, self._params)
+        except InsertWithReturning:
+            raise
         except MultiValuesInsert:
             raise
         except Exception as e:
@@ -1182,6 +1200,8 @@ class Cursor(_BaseCursor):
         sets = self._parameter_sets or 1
         self.params = list(self.params).copy()
         param_types = [param.type for param in self._params._params_list]
+        if not self.params:
+            return
 
         for i in range(sets):
             params = self._params.collect(i)
@@ -1949,7 +1969,12 @@ class Cursor(_BaseCursor):
         self._closed = True
 
     def executemany(self, operation, seq_of_params):
-        super().executemany(operation, seq_of_params)
+        try:
+            super().executemany(operation, seq_of_params)
+        except InsertWithReturning:
+            return
+        except Exception:
+            raise
         self._rowcount = 0
         for i in range(len(self.params)):
             self._rowcount += self._in_message.wire._get()
@@ -2263,13 +2288,21 @@ class EmbdeddedCursor(_BaseCursor):
     def __del__(self):
         try:
             self.close()
-        except:
+        except Exception:
             pass
         return
 
     def _get_cached_info(self):
         return False
 
+    def executemany(self, operation, seq_of_params):
+        try:
+            super().executemany(operation, seq_of_params)
+        except InsertWithReturning:
+            return
+        except Exception:
+            raise
+
     def _get_parameters(self, params_set=0):
         params = self._params.collect(params_set)
         # None = '', '' = b'\x00'
@@ -2394,6 +2427,7 @@ class EmbdeddedCursor(_BaseCursor):
         sqlcode = 0
         message = None
         try:
+            print("!!!! _send_direct_query_request:params", [statement, params])
             self._result_set = self._sql.exec(statement, *params)
             self._rowcount = self._result_set.ResultSet._ROWCOUNT
             self._get_column_info()

intersystems_iris/dbapi/_IRISStream.py

@@ -58,6 +58,8 @@ class IRISStream:
             if not self._binary:
                 result = str(result, self._locale)
 
+        if self._binary:
+            return bytes(result)
         return result
 
 

intersystems_iris/dbapi/_ResultSetRow.py

@@ -162,7 +162,7 @@ class _ResultSetRow:
                 self._list_item.next_offset = self._offsets[key]
                 _DBList._get_list_element(self._list_item)
                 item = _DBList._get(self._list_item, self._locale)
-                _column: _Column = self._columns[idx]
+                _column: _Column = self._columns[key]
                 ctype = _column.type
                 value_type = self._types[ctype] if ctype in self._types else None
                 try:

intersystems_iris/dbapi/preparser/_PreParser.py

@@ -11,6 +11,7 @@ from intersystems_iris.dbapi._Parameter import ParameterMode
 from intersystems_iris.dbapi.preparser._Token import TOKEN
 from intersystems_iris.dbapi.preparser._Scanner import ParseToken
 
+
 class MultiValuesInsert(Exception):
 
     def __init__(self, *args: object, query: str, rows: int, params=None) -> None:
@@ -20,6 +21,15 @@ class MultiValuesInsert(Exception):
         self.params = params
     
 
+class InsertWithReturning(Exception):
+
+    def __init__(self, *args: object, insert_query: str, insert_params, select_query: str) -> None:
+        super().__init__(*args)
+        self.insert_query = insert_query
+        self.insert_params = insert_params
+        self.select_query = select_query
+
+
 # May want to move to its own file eventually
 # SQL Statement Types
 class StatementType(enum.IntEnum):
@@ -480,6 +490,11 @@ class _PreParser(object):
         if found_insert:
             self.Tokenize(t_query)
 
+        _, t_query, t_select_query = self.InsertReturning(t_query)
+        if t_select_query:
+            raise InsertWithReturning(insert_query=t_query, insert_params=p_Parameters, select_query=t_select_query)
+        self.Tokenize(t_query)
+
         #  Resolve the tokens and determine output
         return self.Resolve(t_query, p_Parameters)
 
@@ -549,9 +564,39 @@ class _PreParser(object):
             new_query += _query(False)
             
             return found, new_query
-        except:
+        except Exception:
             return False, query
-        
+
+    def InsertReturning(self, query):
+        plain_query = ''
+
+        tokens = self.m_Tokens.GetEnumerator()
+        keywords = list(self.s_StatementTable.keys()) + list(self.s_ParsedStatements.keys()) + list(self.s_TransactionStatements.keys())
+        while tokens.MoveNext() and not tokens.Current().UpperOnOf(keywords):
+            plain_query += tokens.Current().Lexeme + ' '
+        if tokens.AtEnd() or not tokens.Current().UpperEquals("INSERT"):
+            return False, query, None
+
+        if not tokens.MoveNext() or not tokens.Current().UpperEquals("INTO"):
+            return False, query, None
+        plain_query += 'INSERT INTO '
+        table_name = ""
+        while tokens.MoveNext() and not tokens.Current().UpperOnOf(["(", "SET", "VALUES", "DEFAULT"]):
+            table_name += tokens.Current().Lexeme + ' '
+        plain_query += table_name + ' ' + tokens.Current().Lexeme + ' '
+        while tokens.MoveNext() and not tokens.Current().UpperEquals("RETURNING"):
+            plain_query += tokens.Current().Lexeme + ' '
+
+        select_query = None
+        if not tokens.AtEnd():
+            select_query = 'SELECT '
+            while tokens.MoveNext():
+                select_query += tokens.Current().Lexeme + ' '
+            select_query += "FROM " + table_name
+            select_query += " WHERE %ID %INLIST ?"
+
+        return False, plain_query, select_query
+
     def InsertMultiValues(self, query):
         new_query = ''
         values_list = []
@@ -580,7 +625,10 @@ class _PreParser(object):
                     break
                 if token.TokenType is TOKEN.CONSTANT:
                     values += '?'
-                    params += [token.Lexeme] 
+                    param = token.Lexeme
+                    if param.__len__ and param[0] == "'" and param[0] == param[-1]:
+                        param = param[1: -1]
+                    params += [param]
                 else:    
                     values += token.Lexeme
                 values += ' '
@@ -1047,6 +1095,7 @@ class _PreParser(object):
                     nParamIndex += 1
                     if nParamIndex == length + 1:
                         break
+
         return pOut
 
     # '?' represents a parameter; adds a parameter to p_Parameters if none were provided

intersystems_iris/dbapi/preparser/_Token.py

@@ -76,6 +76,9 @@ It records the classification of the token as well as retaining the original str
     def UpperEquals(self, p_str):
         return self.UpperLexeme == p_str
 
+    def UpperOnOf(self, p_str_list):
+        return self.UpperLexeme in p_str_list
+
     def UpperContains(self, p_str):
         return p_str in self.UpperLexeme
 

intersystems_iris/dbapi/preparser/_TokenList.py

@@ -216,6 +216,9 @@ class LinkedListEnumerator(ITokenEnumerator):
     def Current(self):
         return self.m_Current.GetValue()
 
+    def AtEnd(self):
+        return self.m_bEOF
+
     def MoveNext(self):
         if self.m_bEOF:
             return False

sqlalchemy_iris/base.py

@@ -653,6 +653,20 @@ class IRISDDLCompiler(sql.compiler.DDLCompiler):
     def visit_check_constraint(self, constraint, **kw):
         pass
 
+    def create_table_constraints(self, table, **kw):
+        description = ""
+        comment = table.comment
+        if comment:
+            # hack to keep \r, kind of
+            comment = comment.replace('\r', '\n\t')
+            literal = self.sql_compiler.render_literal_value(comment, sqltypes.String())
+            description = "%DESCRIPTION " + literal
+
+        constraints = super().create_table_constraints(table, **kw)
+        if constraints and description:
+            description = ", \n\t" + description
+        return constraints + description
+
     def visit_add_constraint(self, create, **kw):
         if isinstance(create.element, schema.CheckConstraint):
             raise exc.CompileError("Can't add CHECK constraint")
@@ -701,6 +715,7 @@ class IRISDDLCompiler(sql.compiler.DDLCompiler):
 
         comment = column.comment
         if comment is not None:
+            comment = comment.replace('\r', '\n\t')
             literal = self.sql_compiler.render_literal_value(comment, sqltypes.String())
             colspec.append("%DESCRIPTION " + literal)
 
@@ -883,6 +898,12 @@ class IRISDialect(default.DefaultDialect):
     type_compiler = IRISTypeCompiler
     execution_ctx_cls = IRISExecutionContext
 
+    insert_returning = True
+    insert_executemany_returning = True
+    insert_executemany_returning_sort_by_parameter_order = True
+    update_executemany_returning = False
+    delete_executemany_returning = False
+
     construct_arguments = [
         (schema.Index, {"include": None}),
     ]
@@ -1105,6 +1126,38 @@ There are no access to %Dictionary, may be required for some advanced features,
             return "SQLUser"
         return schema
 
+    @reflection.cache
+    def get_table_options(self, connection, table_name, schema=None, **kw):
+        if not self.has_table(connection=connection, table_name=table_name, schema=schema):
+            raise exc.NoSuchTableError(
+                f"{schema}.{table_name}" if schema else table_name
+            ) from None
+        return {}
+
+    @reflection.cache
+    def get_table_comment(self, connection, table_name, schema=None, **kw):
+        if not self.has_table(connection=connection, table_name=table_name, schema=schema):
+            raise exc.NoSuchTableError(
+                f"{schema}.{table_name}" if schema else table_name
+            ) from None
+
+        tables = ischema.tables
+        schema_name = self.get_schema(schema)
+
+        s = sql.select(tables.c.description).where(
+            sql.and_(
+                tables.c.table_schema == str(schema_name),
+                tables.c.table_name == str(table_name),
+            )
+        )
+        comment = connection.execute(s).scalar()
+        if comment:
+            # make it as \r
+            comment = comment.replace(' \t\t\t\t', '\r')
+            # restore \n
+            comment = comment.replace(' \t\t\t', '\n')
+        return {"text": comment}
+
     @reflection.cache
     def get_schema_names(self, connection, **kw):
         s = sql.select(ischema.schemata.c.schema_name).order_by(
@@ -1131,7 +1184,7 @@ There are no access to %Dictionary, may be required for some advanced features,
         return table_names
 
     @reflection.cache
-    def get_temp_table_names(self, connection, dblink=None, **kw):
+    def get_temp_table_names(self, connection, **kw):
         tables = ischema.tables
         s = (
             sql.select(tables.c.table_name)
@@ -1598,6 +1651,7 @@ There are no access to %Dictionary, may be required for some advanced features,
                 columns.c.column_default,
                 columns.c.collation_name,
                 columns.c.auto_increment,
+                columns.c.description,
             )
             .select_from(columns)
             .where(
@@ -1650,7 +1704,12 @@ There are no access to %Dictionary, may be required for some advanced features,
                 sqlComputeCode = row[property.c.SqlComputeCode]
                 calculated = row[property.c.Calculated]
                 transient = row[property.c.Transient]
-            # description = row[columns.c.description]
+            comment = row[columns.c.description]
+            if comment:
+                # make it as \r
+                comment = comment.replace(' \t\t\t\t', '\r')
+                # restore \n
+                comment = comment.replace(' \t\t\t', '\n')
 
             coltype = self.ischema_names.get(type_, None)
 
@@ -1696,7 +1755,7 @@ There are no access to %Dictionary, may be required for some advanced features,
                 "nullable": nullable,
                 "default": default,
                 "autoincrement": autoincrement,
-                # "comment": description,
+                "comment": comment,
             }
             if sqlComputeCode and "set {*} = " in sqlComputeCode.lower():
                 sqltext = sqlComputeCode

sqlalchemy_iris/information_schema.py

@@ -44,6 +44,7 @@ tables = Table(
     Column("TABLE_NAME", String, key="table_name"),
     Column("TABLE_TYPE", String, key="table_type"),
     Column("CLASSNAME", String, key="classname"),
+    Column("DESCRIPTION", String, key="description"),
     schema="INFORMATION_SCHEMA",
 )
 
@@ -69,7 +70,7 @@ columns = Table(
     Column("AUTO_INCREMENT", YESNO, key="auto_increment"),
     Column("UNIQUE_COLUMN", YESNO, key="unique_column"),
     Column("PRIMARY_KEY", YESNO, key="primary_key"),
-    Column("DESCIPTION", String, key="desciption"),
+    Column("DESCRIPTION", String, key="description"),
     schema="INFORMATION_SCHEMA",
 )
 property_definition = Table(

sqlalchemy_iris/requirements.py

@@ -58,6 +58,22 @@ class Requirements(SuiteRequirements, AlembicRequirements):
 
         return exclusions.open()
 
+    @property
+    def reflect_table_options(self):
+        return exclusions.open()
+
+    @property
+    def comment_reflection(self):
+        return exclusions.open()
+
+    @property
+    def insert_returning(self):
+        return exclusions.open()
+
+    @property
+    def unusual_column_name_characters(self):
+        return exclusions.open()
+
     @property
     def computed_columns(self):
         "Supports computed columns"

{sqlalchemy_iris-0.15.5.dist-info → sqlalchemy_iris-0.15.6b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: sqlalchemy-iris
-Version: 0.15.5
+Version: 0.15.6b1
 Summary: InterSystems IRIS for SQLAlchemy
 Home-page: https://github.com/caretdev/sqlalchemy-iris
 Maintainer: CaretDev
@@ -23,6 +23,7 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: SQLAlchemy>=1.3
+Dynamic: requires-dist
 
 sqlalchemy-iris
 ===

{sqlalchemy_iris-0.15.5.dist-info → sqlalchemy_iris-0.15.6b1.dist-info}/RECORD

@@ -32,20 +32,20 @@ intersystems_iris/_PythonGateway.py,sha256=miV92LhCqsuBIRpLix1oqFjl5SCw9Df-GMTD6
 intersystems_iris/_SharedMemorySocket.py,sha256=2iUaS1FdJNSCUEaE-VT0O_dxF6NRwqZSxlyLfwhT9_E,4330
 intersystems_iris/__init__.py,sha256=Tk1tD28LwvF6X3yXQsJFLE1Bc-PR3gUJWcX5UnNYOdY,1773
 intersystems_iris/__main__.py,sha256=rCtINTfJcADMAsw1ja-MEO7Q-XekrWthYowzWV8xGIQ,218
-intersystems_iris/dbapi/_Column.py,sha256=VCLHLXs3wuGcUa9w_qy7HBFsuGvhmmI3kGYBagQg59U,2535
-intersystems_iris/dbapi/_DBAPI.py,sha256=PZWhstxBQMw6X6AFL0IObvTzY9bJEl6u93keCrNGRmA,103103
+intersystems_iris/dbapi/_Column.py,sha256=WgrqlZru9KxHveErKv6qzs8RSTeYlidK9DvuVkjpvIk,2632
+intersystems_iris/dbapi/_DBAPI.py,sha256=UEZmr5pHF6TUqtqZiM91750SNrBP-qQdWtVF2Tcd8f4,104356
 intersystems_iris/dbapi/_Descriptor.py,sha256=IjyITxvjygDrhpk-0lGhdqQPh91SG6nTb1vi-AqyJNI,1391
-intersystems_iris/dbapi/_IRISStream.py,sha256=dGJntWo4HXgM1nUHZl2hA4xHkBFEU2xkoEplVDFWhnA,2115
+intersystems_iris/dbapi/_IRISStream.py,sha256=M3d0SUfE7vyqCxbquSNaRc43J4Xc9i0XGWJnIJzUVVA,2173
 intersystems_iris/dbapi/_Message.py,sha256=jpLG3HZElqp981iNPFW8UNRO3NbHf6poEv6yywX0Ssw,4076
 intersystems_iris/dbapi/_Parameter.py,sha256=lvPlQkoLlyEjg5J_a9t2I_6vRDkAav6kN1fGyukH4DY,5293
 intersystems_iris/dbapi/_ParameterCollection.py,sha256=kcgNiGv2nH5AwuA6LlPpM4dWqhSqRyD3VtwqHqDGRGU,5541
-intersystems_iris/dbapi/_ResultSetRow.py,sha256=tEQCttO6L2McLfcP7-PIltIu5L9cNzTI1jZ2IR7tdRg,13777
+intersystems_iris/dbapi/_ResultSetRow.py,sha256=enLGhY7FEZr1VGG-i8vojow2QJxOm-XDM93F1eHtu3U,13777
 intersystems_iris/dbapi/_SQLType.py,sha256=IlDacXwQzUMWaJ02Zsu2bUfvUC3-5mBx-m6mE0Yp7ts,557
 intersystems_iris/dbapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-intersystems_iris/dbapi/preparser/_PreParser.py,sha256=024w-s3n_JNsk_ISC8avJMK3QEZE3hSuD0Nr8arJdZw,78828
+intersystems_iris/dbapi/preparser/_PreParser.py,sha256=CjvU6uQjIo4t-HvvoxERpc_wZZkqDCM8U6GOFVLWr3c,80925
 intersystems_iris/dbapi/preparser/_Scanner.py,sha256=xA8rkKsaVba_mAgoXEeliyuMxNKe4vVmmw_klukdf_U,16163
-intersystems_iris/dbapi/preparser/_Token.py,sha256=9ZYrjvYJtMApAR7RtYzp32Hcoo3jB_YpG7ECo7p6QHA,2304
-intersystems_iris/dbapi/preparser/_TokenList.py,sha256=P74kA3DXxi7imt0mea4LPjCCc_gk50zsYLOCWON_JvA,6770
+intersystems_iris/dbapi/preparser/_Token.py,sha256=6hecLgne6ErgFIF4-dP_CLqsGBBDdlf3tXeQQfdI_uE,2388
+intersystems_iris/dbapi/preparser/_TokenList.py,sha256=ae2kwIJP9-o7BOfaEuuQ5pHWYil7o18Mm40oIEyWIAM,6819
 intersystems_iris/dbapi/preparser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 intersystems_iris/pex/_BusinessHost.py,sha256=arBAUZetLPhJY2on3BK5BJOZXXjLVJ3gr_VvkncbWDs,4370
 intersystems_iris/pex/_BusinessOperation.py,sha256=gEyPF6A04si6UqVUY_75ulYzjMBhe337GTkcbK2OGfA,5241
@@ -61,27 +61,21 @@ intersystems_iris/pex/_InboundAdapter.py,sha256=gZlWl7afumamkj8pNbpLyKFSzhaTAiAX
 intersystems_iris/pex/_Message.py,sha256=Ugaa_lsEYke__pI5kdC7phAuyPQ7rxXUcROJL4cUxVQ,320
 intersystems_iris/pex/_OutboundAdapter.py,sha256=ao2Ubbta2DcrQGdzDUD_j1Zsk8bvUfcZNKTZkzPTNBU,1628
 intersystems_iris/pex/__init__.py,sha256=l_I1dpnluWawbFrGMDC0GLHpuHwjbpd-nho8otFX6TE,1379
-iris/__init__.py,sha256=i0PK20mjoWOnFPQM0pHF8wMjjmh-5i1xLEduy4r-q9o,2036
-iris/__init__.pyi,sha256=HPv6Lot6yZt8XXj3Rb0CrVO9ChDbKVpE3ID1SIqAlwU,9766
-iris/_cli.py,sha256=HsmaY22h2a9EofCLcm_CU-ZikQNqFPDlH5xDvLon-Ko,1983
-iris/iris_ipm.py,sha256=Q0jcNItjywlqOPZr0hgdTFSeLPNEmB-tcICOI_cXnaY,790
-iris/iris_ipm.pyi,sha256=j7CNUZcjeDu5sgeWUZJO_Qi4vQmHh6aD-jPWv8OdoUs,374
-iris/iris_utils.py,sha256=kg80O3yRpHIutM-mCyr4xCeTvKWPE-Kai-b6Dxw4vQ4,9882
 irisnative/_IRISNative.py,sha256=HQ4nBhc8t8_5OtxdMG-kx1aa-T1znf2I8obZOPLOPzg,665
 irisnative/__init__.py,sha256=6YmvBLQSURsCPKaNg7LK-xpo4ipDjrlhKuwdfdNb3Kg,341
 sqlalchemy_iris/__init__.py,sha256=2bckDQ0AJJ9DfuAc20VVQNiK-YBhpYJMdo_C0qJwPHQ,1183
 sqlalchemy_iris/alembic.py,sha256=L58qBIj6HwLmtU6FS5RXKW0gHr1mNTrBSChEllSh1n0,6607
-sqlalchemy_iris/base.py,sha256=WdRRnB31W50fWqptTyalgSM7AMA73Qye7sugU6SFuDE,52409
+sqlalchemy_iris/base.py,sha256=xkAYNo6TFIF7f6cvP2h_7TSiEJBbprmYrmpXM0FkWAM,54679
 sqlalchemy_iris/embedded.py,sha256=5WZ78PIYB_pPyaLrK4E7kHUsGBRiwzYHjsTDiNYHUGg,819
-sqlalchemy_iris/information_schema.py,sha256=Ei1gAHXn4fWpvmUzwf-2hGslU458uQXFt1s0r1NAj2Y,6132
+sqlalchemy_iris/information_schema.py,sha256=FUL3z_viGjjOvDA71Mbk5k94dUGcLV4dW1xHxBgM1rk,6188
 sqlalchemy_iris/iris.py,sha256=Of0Ruc9W2c5ll5sjAy1xRo4tf1m0l_ab0vAdacTv3Yw,276
 sqlalchemy_iris/irisasync.py,sha256=7Kmso-RGjxQi9Y4x-zQaUk1ylDQ7TDvpvlZh_syJtGw,312
 sqlalchemy_iris/provision.py,sha256=drorbIgNO770Ws0XiCRXY_sDbQGIy2_zzNK3KYrDetY,198
-sqlalchemy_iris/requirements.py,sha256=2MPADPOk3qvXCyr7xXvkl_MfkE8v75Z3yGJO0RbzRog,7560
+sqlalchemy_iris/requirements.py,sha256=X0e_aeO83ucg3iwnX5n_CPUcwmav_SqLbaxj82_-MiU,7901
 sqlalchemy_iris/types.py,sha256=mtm5wQQuA4pE6WB4EUHzAcpdBCLfZKHrY9qOcdllc7E,11077
-sqlalchemy_iris-0.15.5.dist-info/LICENSE,sha256=RQmigqltsLq8lfOBc_KwtL0gkODyUCNpU-0ZiZwGlho,1075
-sqlalchemy_iris-0.15.5.dist-info/METADATA,sha256=Y4djdLK4S4XxMPTVCME_vgueHGDmgKlc4KV0hIOO1gs,2354
-sqlalchemy_iris-0.15.5.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-sqlalchemy_iris-0.15.5.dist-info/entry_points.txt,sha256=zjOwyJPXHsNAeQP0n6l2_pav2U__rTAiS_Bk_IEmSlU,184
-sqlalchemy_iris-0.15.5.dist-info/top_level.txt,sha256=mjpHqFjekbB1TWr3xI3o4AqN3Spby-_uqyuSSeBDmuw,50
-sqlalchemy_iris-0.15.5.dist-info/RECORD,,
+sqlalchemy_iris-0.15.6b1.dist-info/LICENSE,sha256=RQmigqltsLq8lfOBc_KwtL0gkODyUCNpU-0ZiZwGlho,1075
+sqlalchemy_iris-0.15.6b1.dist-info/METADATA,sha256=kSvVGiMAB7_YFkA9RedFo5IxT0RS0bqHl2YglBqiKS0,2379
+sqlalchemy_iris-0.15.6b1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+sqlalchemy_iris-0.15.6b1.dist-info/entry_points.txt,sha256=zjOwyJPXHsNAeQP0n6l2_pav2U__rTAiS_Bk_IEmSlU,184
+sqlalchemy_iris-0.15.6b1.dist-info/top_level.txt,sha256=QRY18YUXUJrRde4aayj_brj0lr2LBRVZS1ZoVoDFVS0,45
+sqlalchemy_iris-0.15.6b1.dist-info/RECORD,,

{sqlalchemy_iris-0.15.5.dist-info → sqlalchemy_iris-0.15.6b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{sqlalchemy_iris-0.15.5.dist-info → sqlalchemy_iris-0.15.6b1.dist-info}/top_level.txt

@@ -1,4 +1,3 @@
 intersystems_iris
-iris
 irisnative
 sqlalchemy_iris

iris/__init__.py

@@ -1,66 +0,0 @@
-import os
-import sys
-import importlib
-
-from .iris_ipm import ipm
-from .iris_utils import update_dynalib_path
-
-# check for install dir in environment
-# environment to check is IRISINSTALLDIR
-# if not found, raise exception and exit
-# ISC_PACKAGE_INSTALLDIR - defined by default in Docker images
-installdir = os.environ.get('IRISINSTALLDIR') or os.environ.get('ISC_PACKAGE_INSTALLDIR')
-if installdir is None:
-        raise Exception("""Cannot find InterSystems IRIS installation directory
-    Please set IRISINSTALLDIR environment variable to the InterSystems IRIS installation directory""")
-
-__sysversion_info = sys.version_info
-__syspath = sys.path
-__osname = os.name
-
-# join the install dir with the bin directory
-__syspath.append(os.path.join(installdir, 'bin'))
-# also append lib/python
-__syspath.append(os.path.join(installdir, 'lib', 'python'))
-
-# update the dynalib path
-update_dynalib_path(os.path.join(installdir, 'bin'))
-
-# save working directory
-__ospath = os.getcwd()
-
-__irispythonint = None
-
-if __osname=='nt':
-    if __sysversion_info.minor==9:
-        __irispythonint = 'pythonint39'
-    elif __sysversion_info.minor==10:
-        __irispythonint = 'pythonint310'
-    elif __sysversion_info.minor==11:
-        __irispythonint = 'pythonint311'
-    elif __sysversion_info.minor==12:
-        __irispythonint = 'pythonint312'
-    elif __sysversion_info.minor==13:
-        __irispythonint = 'pythonint313'
-else:
-    __irispythonint = 'pythonint'
-
-if __irispythonint is not None:
-    # equivalent to from pythonint import *
-    try:
-        __irispythonintmodule = importlib.import_module(__irispythonint)
-    except ImportError:
-        __irispythonint = 'pythonint'
-        __irispythonintmodule = importlib.import_module(__irispythonint)
-    globals().update(vars(__irispythonintmodule))
-
-# restore working directory
-os.chdir(__ospath)
-
-# TODO: Figure out how to hide __syspath and __ospath from anyone that
-#       imports iris.  Tried __all__ but that only applies to this:
-#           from iris import *
-
-#
-# End-of-file
-#

iris/__init__.pyi

@@ -1,236 +0,0 @@
-from __future__ import annotations
-from typing import Any
-from iris.iris_ipm import ipm
-from . import iris_ipm
-__all__ = [ 'check_status', 'cls', 'execute', 'gref', 'ipm', 'iris_ipm', 'lock', 'os', 'ref', 'routine', 'sql', 'system', 'tcommit', 'tlevel', 'trollback', 'trollbackone', 'tstart', 'unlock', 'utils']
-def check_status(self, status):
-    """
-    Raises an exception on an error status, or returns None if no error condition occurs.
-    Example: iris.check_status(st) checks the status code st to see if it contains an error.
-    """
-def cls(self, class_name):
-    """
-    Returns a reference to an InterSystems IRIS class.
-    Example: iris.cls("%SYSTEM.INetInfo").LocalHostName() calls a method in the class %SYSTEM.INetInfo.
-    """
-def execute(self, statements):
-    """
-    execute IRIS statements.
-    Example: iris.execute("set x="Hello"\nw x,!\n") returns nothing.
-    """
-def gref(self, global_name) -> global_ref:
-    """
-    Returns a reference to an InterSystems IRIS global.
-    Example: g = iris.gref("^foo") sets g to a reference to global ^foo
-    """
-def lock(self, lock_list, timeout_value, locktype):
-    """
-    Sets locks, given a list of lock names, an optional timeout value (in seconds), and an optional locktype.
-    Example: iris.lock(["^foo","^bar"], 30, "S") sets locks "^foo" and "^bar", waiting up to 30 seconds, and using shared locks.
-    """
-def ref(self, value):
-    """
-    Creates an iris.ref object with a specified value.
-    Example: iris.ref("hello") creates an iris.ref object with the value "hello"
-    """
-def routine(self, routine, args):
-    """
-    Invokes an InterSystems IRIS routine, optionally at a given tag.
-    Example: iris.routine("Stop^SystemPerformance", "20211221_160620_test") calls tag Stop in routine ^SystemPerformance.
-    """
-def tcommit(self):
-    """
-    Marks a successful end of an InterSystems IRIS transaction.
-    Example: iris.commit() marks the successful end of a transaction and decrements the nesting level by 1
-    """
-def tlevel(self):
-    """
-    Detects whether a transaction is currently in progress and returns the nesting level. Zero means not in a transaction.
-    Example: iris.tlevel() returns the current transaction nesting level, or zero if not in a transaction
-    """
-def trollback(self):
-    """
-    Terminates the current transaction and restores all journaled database values to their values at the start of the transaction.
-    Example: iris.trollback() rolls back all current transactions in progress and resets the transaction nesting level to 0
-    """
-def trollbackone(self):
-    """
-    Rolls back the current level of nested transactions, that is, the one initiated by the most recent tstart().
-    Example: iris.trollbackone() rolls back the current level of nested transactions and decrements the nesting level by 1
-    """
-def tstart(self):
-    """
-    Starts an InterSystems IRIS transaction.
-    Example: iris.tstart() marks the beginning of a transaction.
-    """
-def unlock(self, lock_list, timout_value, locktype):
-    """
-    Removes locks, given a list of lock names, an optional timeout value (in seconds), and an optional locktype.
-    Example: iris.unlock(["^foo","^bar"], 30, "S") removes locks "^foo" and "^bar", waiting up to 30 seconds, and using shared locks.
-    """
-def utils(self):
-    """
-    Returns a reference to the InterSystems IRIS utilities class.
-    Example: iris.utils().$Job() returns the current job number.
-    """
-# Stubs for the gref object
-class global_ref:
-    def data(self, key):
-        """
-        Checks if a node of a global contains data and/or has descendants. The key of the node is passed as a list. Passing a key with the
-        value None (or an empty list) indicates the root node of the global.\n
-        You can use data() to inspect a node to see if it contains data before attempting to access that data and possibly encountering an error.
-        The method returns 0 if the node is undefined (contains no data), 1 if the node is defined (contains data), 10 if the node is undefined
-        but has descendants, or 11 if the node is defined and has descendants.
-        """
-    def get(self, key):
-        """
-        Gets the value stored at a node of a global. The key of the node is passed as a list. Passing a key with the value None (or an empty list)
-        indicates the root node of the global.
-        """
-    def getAsBytes(self, key):
-        """
-        Gets a string value stored at a node of a global and converts it to the Python bytes data type. The key of the node is passed as a list.
-        Passing a key with the value None (or an empty list) indicates the root node of the global.
-        """
-    def keys(self, key):
-        """
-        Returns the keys of a global, starting from a given key. The starting key is passed as a list. Passing an empty list indicates the root node of the global.
-        """
-    def kill(self, key):
-        """
-        Deletes the node of a global, if it exists. The key of the node is passed as a list. This also deletes any descendants of the node.
-        Passing a key with the value None (or an empty list) indicates the root node of the global.
-        """
-    def order(self, key):
-        """
-        Returns the next key in that level of the global, starting from a given key. The starting key is passed as a list.
-        If no key follows the starting key, order() returns None.
-        """
-    def orderiter(self, key):
-        """
-        Returns the keys and values of a global, starting from a given key, down to the next leaf node.
-        The starting key is passed as a list. Passing an empty list indicates the root node of the global.
-        """
-    def query(self, key):
-        """
-        Traverses a global starting at the specified key, returning each key and value.
-        The starting key is passed as a list. Passing an empty list indicates the root node of the global.
-        """
-    def set(self, key, value):
-        """
-        Sets a node in a global to a given value. The key of the node is passed as a list, and value is the value to be stored.
-        Passing a key with the value None (or an empty list) indicates the root node of the global.
-        """
-# stubs for the sql object
-class sql:
-    """
-    The sql object provides access to the InterSystems IRIS SQL API.
-    """
-    def exec(self, query: str) -> Any:
-        """
-        Execute a query
-        """
-    def prepare(self, query: str) -> PreparedQuery:
-        """
-        Prepare a query
-        """
-    class PreparedQuery:
-        def execute(self, **kwargs) -> Any:
-            """
-            Execute a prepared query, you can pass values
-            """
-# stubs for the system object
-class system:
-    """
-    The system object provides access to the InterSystems IRIS system API.
-    The following classes are available:
-    'DocDB', 'Encryption', 'Error', 'Event', 'Monitor', 'Process', 'Python', 'SQL', 'SYS', 'Security', 'Semaphore', 'Status', 'Util', 'Version'
-    """
-    class DocDB:
-        """
-        The DocDB class provides access to the InterSystems IRIS Document Database API.
-        The following methods are available:
-        'CreateDatabase', 'DropAllDatabases', 'DropDatabase', 'Exists', 'GetAllDatabases', 'GetDatabase', 'Help'
-        """
-        def CreateDatabase(self, name: str, path: str, **kwargs) -> Any:
-            """
-            Create a database
-            """
-        def DropAllDatabases(self) -> Any:
-            """
-            Drop all databases
-            """
-        def DropDatabase(self, name: str) -> Any:
-            """
-            Drop a database
-            """
-        def Exists(self, name: str) -> Any:
-            """
-            Check if a database exists
-            """
-        def GetAllDatabases(self) -> Any:
-            """
-            Get all databases
-            """
-        def GetDatabase(self, name: str) -> Any:
-            """
-            Get a database
-            """
-        def Help(self) -> Any:
-            """
-            Get help
-            """
-    def Encryption(self) -> Any:
-        """
-        The Encryption class provides access to the InterSystems IRIS Encryption API.
-        """
-    def Error(self) -> Any:
-        """
-        The Error class provides access to the InterSystems IRIS Error API.
-        """
-    def Event(self) -> Any:
-        """
-        The Event class provides access to the InterSystems IRIS Event API.
-        """
-    def Monitor(self) -> Any:
-        """
-        The Monitor class provides access to the InterSystems IRIS Monitor API.
-        """
-    def Process(self) -> Any:
-        """
-        The Process class provides access to the InterSystems IRIS Process API.
-        """
-    def Python(self) -> Any:
-        """
-        The Python class provides access to the InterSystems IRIS Python API.
-        """
-    def SQL(self) -> Any:
-        """
-        The SQL class provides access to the InterSystems IRIS SQL API.
-        """
-    def SYS(self) -> Any:
-        """
-        The SYS class provides access to the InterSystems IRIS SYS API.
-        """
-    def Security(self) -> Any:
-        """
-        The Security class provides access to the InterSystems IRIS Security API.
-        """
-    def Semaphore(self) -> Any:
-        """
-        The Semaphore class provides access to the InterSystems IRIS Semaphore API.
-        """
-    def Status(self) -> Any:
-        """
-        The Status class provides access to the InterSystems IRIS Status API.
-        """
-    def Util(self) -> Any:
-        """
-        The Util class provides access to the InterSystems IRIS Util API.
-        """
-    def Version(self) -> Any:
-        """
-        The Version class provides access to the InterSystems IRIS Version API.
-        """
-

iris/_cli.py

@@ -1,75 +0,0 @@
-import os
-import sys
-import argparse
-import logging
-
-from . import iris_utils
-import iris
-
-logging.basicConfig(level=logging.INFO)
-
-VENV_BACKUP_GREF = "^Venv.BackUp"
-
-def bind():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--namespace", default="")
-    args = parser.parse_args()
-
-    iris_gref = iris.gref(VENV_BACKUP_GREF)
-
-    path = ""
-
-    libpython = iris_utils.find_libpython()
-    if not libpython:
-        logging.error("libpython not found")
-        raise RuntimeError("libpython not found")
-
-    iris.system.Process.SetNamespace("%SYS")
-
-    config = iris.cls("Config.config").Open()
-
-    # Set the new libpython path
-    iris_gref["PythonRuntimeLibrary"] = config.PythonRuntimeLibrary
-        
-    config.PythonRuntimeLibrary = libpython
-
-    if "VIRTUAL_ENV" in os.environ:
-        # we are not in a virtual environment
-        path = os.path.join(os.environ["VIRTUAL_ENV"], "lib", "python" + sys.version[:4], "site-packages")
-
-    iris_gref["PythonPath"] = config.PythonPath
-
-    config.PythonPath = path
-    
-    config._Save()
-
-    log_config_changes(libpython, path)
-
-def unbind():
-    iris.system.Process.SetNamespace("%SYS")
-    config = iris.cls("Config.config").Open()
-
-    iris_gref = iris.gref(VENV_BACKUP_GREF)
-
-    if iris_gref["PythonRuntimeLibrary"]:
-        config.PythonRuntimeLibrary = iris_gref["PythonRuntimeLibrary"]
-    else:
-        config.PythonRuntimeLibrary = ""
-
-    if iris_gref["PythonPath"]:
-        config.PythonPath = iris_gref["PythonPath"]
-    else:
-        config.PythonPath = ""
-
-    config._Save()
-
-    del iris_gref["PythonRuntimeLibrary"]
-    del iris_gref["PythonPath"]
-    del iris_gref[None]
-
-    log_config_changes(config.PythonRuntimeLibrary, config.PythonPath)
-
-def log_config_changes(libpython, path):
-    logging.info("PythonRuntimeLibrary path set to %s", libpython)
-    logging.info("PythonPath set to %s", path)
-    logging.info("To iris instance %s", iris.cls("%SYS.System").GetUniqueInstanceName())

iris/iris_ipm.py

@@ -1,40 +0,0 @@
-def ipm(cmd, *args):
-    """
-    Executes shell command with IPM:
-    Parameters
-    ----------
-    cmd : str
-        The command to execute
-    Examples
-    --------
-    `ipm('help')`
-    `ipm('load /home/irisowner/dev -v')`
-    `ipm('install webterminal')`
-    """
-
-    import multiprocessing
-    import iris
-
-    def shell(cmd, status):
-        
-
-        status.put(True)
-
-        res = iris.cls("%ZPM.PackageManager").Shell(cmd)
-        print('')
-        if res != 1:
-            status.get()
-            status.put(False)
-
-    manager = multiprocessing.Manager()
-    status = manager.Queue()
-    process = multiprocessing.Process(
-        target=shell,
-        args=(
-            cmd,
-            status,
-        ),
-    )
-    process.start()
-    process.join()
-    return status.get()

iris/iris_ipm.pyi

@@ -1,17 +0,0 @@
-from __future__ import annotations
-__all__ = ['ipm']
-def ipm(cmd, *args):
-    """
-    
-        Executes shell command with IPM:
-        Parameters
-        ----------
-        cmd : str
-            The command to execute
-        Examples
-        --------
-        `ipm('help')`
-        `ipm('load /home/irisowner/dev -v')`
-        `ipm('install webterminal')`
-        
-    """

iris/iris_utils.py

@@ -1,336 +0,0 @@
-"""
-Locate libpython associated with this Python executable.
-"""
-
-# License
-#
-# Copyright 2018, Takafumi Arakaki
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-from __future__ import print_function, absolute_import
-
-from logging import getLogger
-import ctypes.util
-import functools
-import os
-import sys
-import sysconfig
-import re
-
-logger = getLogger("find_libpython")
-
-is_windows = os.name == "nt"
-is_apple = sys.platform == "darwin"
-
-SHLIB_SUFFIX = sysconfig.get_config_var("SHLIB_SUFFIX")
-if SHLIB_SUFFIX is None:
-    if is_windows:
-        SHLIB_SUFFIX = ".dll"
-    else:
-        SHLIB_SUFFIX = ".so"
-if is_apple:
-    # sysconfig.get_config_var("SHLIB_SUFFIX") can be ".so" in macOS.
-    # Let's not use the value from sysconfig.
-    SHLIB_SUFFIX = ".dylib"
-
-
-def linked_libpython():
-    """
-    Find the linked libpython using dladdr (in *nix).
-
-    Calling this in Windows always return `None` at the moment.
-
-    Returns
-    -------
-    path : str or None
-        A path to linked libpython.  Return `None` if statically linked.
-    """
-    if is_windows:
-        return None
-    return _linked_libpython_unix()
-
-
-class Dl_info(ctypes.Structure):
-    _fields_ = [
-        ("dli_fname", ctypes.c_char_p),
-        ("dli_fbase", ctypes.c_void_p),
-        ("dli_sname", ctypes.c_char_p),
-        ("dli_saddr", ctypes.c_void_p),
-    ]
-
-
-def _linked_libpython_unix():
-    libdl = ctypes.CDLL(ctypes.util.find_library("dl"))
-    libdl.dladdr.argtypes = [ctypes.c_void_p, ctypes.POINTER(Dl_info)]
-    libdl.dladdr.restype = ctypes.c_int
-
-    dlinfo = Dl_info()
-    retcode = libdl.dladdr(
-        ctypes.cast(ctypes.pythonapi.Py_GetVersion, ctypes.c_void_p),
-        ctypes.pointer(dlinfo))
-    if retcode == 0:  # means error
-        return None
-    path = os.path.realpath(dlinfo.dli_fname.decode())
-    if path == os.path.realpath(sys.executable):
-        return None
-    return path
-
-
-def library_name(name, suffix=SHLIB_SUFFIX, is_windows=is_windows):
-    """
-    Convert a file basename `name` to a library name (no "lib" and ".so" etc.)
-
-    >>> library_name("libpython3.7m.so")                   # doctest: +SKIP
-    'python3.7m'
-    >>> library_name("libpython3.7m.so", suffix=".so", is_windows=False)
-    'python3.7m'
-    >>> library_name("libpython3.7m.dylib", suffix=".dylib", is_windows=False)
-    'python3.7m'
-    >>> library_name("python37.dll", suffix=".dll", is_windows=True)
-    'python37'
-    """
-    if not is_windows and name.startswith("lib"):
-        name = name[len("lib"):]
-    if suffix and name.endswith(suffix):
-        name = name[:-len(suffix)]
-    return name
-
-
-def append_truthy(list, item):
-    if item:
-        list.append(item)
-
-
-def uniquifying(items):
-    """
-    Yield items while excluding the duplicates and preserving the order.
-
-    >>> list(uniquifying([1, 2, 1, 2, 3]))
-    [1, 2, 3]
-    """
-    seen = set()
-    for x in items:
-        if x not in seen:
-            yield x
-        seen.add(x)
-
-
-def uniquified(func):
-    """ Wrap iterator returned from `func` by `uniquifying`. """
-    @functools.wraps(func)
-    def wrapper(*args, **kwds):
-        return uniquifying(func(*args, **kwds))
-    return wrapper
-
-
-@uniquified
-def candidate_names(suffix=SHLIB_SUFFIX):
-    """
-    Iterate over candidate file names of libpython.
-
-    Yields
-    ------
-    name : str
-        Candidate name libpython.
-    """
-    LDLIBRARY = sysconfig.get_config_var("LDLIBRARY")
-    if LDLIBRARY:
-        yield LDLIBRARY
-
-    LIBRARY = sysconfig.get_config_var("LIBRARY")
-    if LIBRARY:
-        yield os.path.splitext(LIBRARY)[0] + suffix
-
-    dlprefix = "" if is_windows else "lib"
-    sysdata = dict(
-        v=sys.version_info,
-        # VERSION is X.Y in Linux/macOS and XY in Windows:
-        VERSION=(sysconfig.get_config_var("VERSION") or
-                 "{v.major}.{v.minor}".format(v=sys.version_info)),
-        ABIFLAGS=(sysconfig.get_config_var("ABIFLAGS") or
-                  sysconfig.get_config_var("abiflags") or ""),
-    )
-
-    for stem in [
-            "python{VERSION}{ABIFLAGS}".format(**sysdata),
-            "python{VERSION}".format(**sysdata),
-            "python{v.major}".format(**sysdata),
-            "python",
-            ]:
-        yield dlprefix + stem + suffix
-
-
-
-@uniquified
-def candidate_paths(suffix=SHLIB_SUFFIX):
-    """
-    Iterate over candidate paths of libpython.
-
-    Yields
-    ------
-    path : str or None
-        Candidate path to libpython.  The path may not be a fullpath
-        and may not exist.
-    """
-
-    yield linked_libpython()
-
-    # List candidates for directories in which libpython may exist
-    lib_dirs = []
-    append_truthy(lib_dirs, sysconfig.get_config_var('LIBPL'))
-    append_truthy(lib_dirs, sysconfig.get_config_var('srcdir'))
-    append_truthy(lib_dirs, sysconfig.get_config_var("LIBDIR"))
-
-    # LIBPL seems to be the right config_var to use.  It is the one
-    # used in python-config when shared library is not enabled:
-    # https://github.com/python/cpython/blob/v3.7.0/Misc/python-config.in#L55-L57
-    #
-    # But we try other places just in case.
-
-    if is_windows:
-        lib_dirs.append(os.path.join(os.path.dirname(sys.executable)))
-    else:
-        lib_dirs.append(os.path.join(
-            os.path.dirname(os.path.dirname(sys.executable)),
-            "lib"))
-
-    # For macOS:
-    append_truthy(lib_dirs, sysconfig.get_config_var("PYTHONFRAMEWORKPREFIX"))
-
-    lib_dirs.append(sys.exec_prefix)
-    lib_dirs.append(os.path.join(sys.exec_prefix, "lib"))
-
-    lib_basenames = list(candidate_names(suffix=suffix))
-
-    for directory in lib_dirs:
-        for basename in lib_basenames:
-            yield os.path.join(directory, basename)
-
-    # In macOS and Windows, ctypes.util.find_library returns a full path:
-    for basename in lib_basenames:
-        yield ctypes.util.find_library(library_name(basename))
-
-# Possibly useful links:
-# * https://packages.ubuntu.com/bionic/amd64/libpython3.6/filelist
-# * https://github.com/Valloric/ycmd/issues/518
-# * https://github.com/Valloric/ycmd/pull/519
-
-
-def normalize_path(path, suffix=SHLIB_SUFFIX, is_apple=is_apple):
-    """
-    Normalize shared library `path` to a real path.
-
-    If `path` is not a full path, `None` is returned.  If `path` does
-    not exists, append `SHLIB_SUFFIX` and check if it exists.
-    Finally, the path is canonicalized by following the symlinks.
-
-    Parameters
-    ----------
-    path : str ot None
-        A candidate path to a shared library.
-    """
-    if not path:
-        return None
-    if not os.path.isabs(path):
-        return None
-    if os.path.exists(path):
-        return os.path.realpath(path)
-    if os.path.exists(path + suffix):
-        return os.path.realpath(path + suffix)
-    if is_apple:
-        return normalize_path(_remove_suffix_apple(path),
-                              suffix=".so", is_apple=False)
-    return None
-
-
-def _remove_suffix_apple(path):
-    """
-    Strip off .so or .dylib.
-
-    >>> _remove_suffix_apple("libpython.so")
-    'libpython'
-    >>> _remove_suffix_apple("libpython.dylib")
-    'libpython'
-    >>> _remove_suffix_apple("libpython3.7")
-    'libpython3.7'
-    """
-    if path.endswith(".dylib"):
-        return path[:-len(".dylib")]
-    if path.endswith(".so"):
-        return path[:-len(".so")]
-    return path
-
-
-@uniquified
-def finding_libpython():
-    """
-    Iterate over existing libpython paths.
-
-    The first item is likely to be the best one.
-
-    Yields
-    ------
-    path : str
-        Existing path to a libpython.
-    """
-    logger.debug("is_windows = %s", is_windows)
-    logger.debug("is_apple = %s", is_apple)
-    for path in candidate_paths():
-        logger.debug("Candidate: %s", path)
-        normalized = normalize_path(path)
-        if normalized:
-            logger.debug("Found: %s", normalized)
-            yield normalized
-        else:
-            logger.debug("Not found.")
-
-
-def find_libpython():
-    """
-    Return a path (`str`) to libpython or `None` if not found.
-
-    Parameters
-    ----------
-    path : str or None
-        Existing path to the (supposedly) correct libpython.
-    """
-    for path in finding_libpython():
-        return os.path.realpath(path)
-
-def update_dynalib_path(dynalib_path):
-    # Determine the environment variable based on the operating system
-    env_var = 'PATH'
-    if not sys.platform.startswith('win'):
-        if sys.platform == 'darwin':
-            env_var = 'DYLD_LIBRARY_PATH'
-        else:
-            env_var = 'LD_LIBRARY_PATH'
-            
-    # Get the current value of the environment variable
-    current_paths = os.environ.get(env_var, '')
-    
-    # Update the environment variable by appending the dynalib path
-    # Note: You can prepend instead by reversing the order in the join
-    new_paths = f"{current_paths}:{dynalib_path}" if current_paths else dynalib_path
-    
-    # Update the environment variable
-    os.environ[env_var] = new_paths
-