kodexa 7.0.12399293688__py3-none-any.whl → 7.4.412416252968__py3-none-any.whl

kodexa/model/model.py

@@ -2443,11 +2443,14 @@ class Document(object):
     def get_exceptions(self) -> List[ContentException]:
         return self._persistence_layer.get_exceptions()
 
-    def get_external_data(self) -> dict:
-        return self._persistence_layer.get_external_data()
+    def get_external_data(self, key="default") -> dict:
+        return self._persistence_layer.get_external_data(key)
 
-    def set_external_data(self, external_data:dict):
-        return self._persistence_layer.set_external_data(external_data)
+    def get_external_data_keys(self) -> list[str]:
+        return self._persistence_layer.get_external_data_keys()
+
+    def set_external_data(self, external_data:dict, key="default"):
+        return self._persistence_layer.set_external_data(external_data, key)
 
     def get_steps(self) -> list[ProcessingStep]:
         return self._persistence_layer.get_steps()

kodexa/model/persistence.py

@@ -1156,22 +1156,6 @@ class SqliteDocumentPersistence(object):
 
         return content_nodes
 
-    def __ensure_ed_table_exists(self):
-        """
-        Ensure the 'ed' table exists in the database.
-        Creates the table if it does not exist.
-        """
-        self.cursor.execute("""
-            CREATE TABLE IF NOT EXISTS ed (
-                obj BLOB
-            )
-        """)
-
-        # Check if the table has any rows, if not, insert an initial empty row
-        result = self.cursor.execute("SELECT COUNT(*) FROM ed").fetchone()
-        if result[0] == 0:
-            self.cursor.execute("INSERT INTO ed (obj) VALUES (?)", [sqlite3.Binary(msgpack.packb({}))])
-
     def __ensure_validations_table_exists(self):
         """
         Ensure the 'validations' table exists in the database.
@@ -1213,31 +1197,98 @@ class SqliteDocumentPersistence(object):
             return [DocumentTaxonValidation.model_validate(v) for v in msgpack.unpackb(result[0])]
         return []
 
-    def set_external_data(self, external_data: dict):
+    def set_external_data(self, external_data: dict, key: str = "default"):
         """
-        Sets the external data for the document.
+        Sets the external data for the document for a specific key.
 
         Args:
             external_data (dict): The external data to store, must be JSON serializable.
+            key (str): The key to store the data under, defaults to "default"
         """
         self.__ensure_ed_table_exists()
         serialized_data = sqlite3.Binary(msgpack.packb(external_data))
-        self.cursor.execute("UPDATE ed SET obj = ? WHERE rowid = 1", [serialized_data])
+        self.cursor.execute("DELETE FROM ed WHERE key = ?", [key])
+        self.cursor.execute("INSERT INTO ed (key, obj) VALUES (?, ?)", [key, serialized_data])
         self.connection.commit()
 
-    def get_external_data(self) -> dict:
+    def get_external_data(self, key: str = "default") -> dict:
         """
-        Gets the external data associated with this document.
+        Gets the external data associated with this document for a specific key.
+
+        Args:
+            key (str): The key to retrieve data for, defaults to "default"
 
         Returns:
-            dict: The external data stored in the ed table.
+            dict: The external data stored in the ed table for the given key.
         """
         self.__ensure_ed_table_exists()
-        result = self.cursor.execute("SELECT obj FROM ed WHERE rowid = 1").fetchone()
+        result = self.cursor.execute("SELECT obj FROM ed WHERE key = ?", [key]).fetchone()
         if result and result[0]:
             return msgpack.unpackb(result[0])
         return {}
 
+    def get_external_data_keys(self) -> List[str]:
+        """
+        Gets all keys under which external data is stored.
+
+        Returns:
+            List[str]: A list of all keys that have external data stored.
+        """
+        self.__ensure_ed_table_exists()
+        results = self.cursor.execute("SELECT key FROM ed").fetchall()
+        return [row[0] for row in results]
+
+    def __ensure_ed_table_exists(self):
+        """
+        Ensure the 'ed' table exists in the database.
+        Creates the table if it does not exist.
+        """
+        # First check if the old table exists and has id column
+        old_table = self.cursor.execute("""
+            SELECT name FROM sqlite_master 
+            WHERE type='table' AND name='ed'
+        """).fetchone()
+
+        if old_table:
+            # Check if table has id column
+            table_info = self.cursor.execute("PRAGMA table_info(ed)").fetchall()
+            has_id_column = any(col[1] == 'id' for col in table_info)
+
+            if has_id_column:
+                # Get the old data and drop the table
+                data = self.cursor.execute("SELECT obj FROM ed").fetchone()
+                self.cursor.execute("DROP TABLE ed")
+
+                # Create new table with key column
+                self.cursor.execute("""
+                    CREATE TABLE ed (
+                        key TEXT PRIMARY KEY,
+                        obj BLOB
+                    )
+                """)
+
+                # If there was data in the old table, insert it with default key
+                if data:
+                    self.cursor.execute("INSERT INTO ed (key, obj) VALUES (?, ?)",
+                                      ["default", data[0]])
+            else:
+                # Table exists but doesn't need migration - do nothing
+                return
+        else:
+            # Create new table if it doesn't exist
+            self.cursor.execute("""
+                CREATE TABLE IF NOT EXISTS ed (
+                    key TEXT PRIMARY KEY,
+                    obj BLOB
+                )
+            """)
+
+            # Check if default key exists, if not insert empty data
+            result = self.cursor.execute("SELECT COUNT(*) FROM ed WHERE key = 'default'").fetchone()
+            if result[0] == 0:
+                self.cursor.execute("INSERT INTO ed (key, obj) VALUES (?, ?)",
+                                  ["default", sqlite3.Binary(msgpack.packb({}))])
+
     def __ensure_steps_table_exists(self):
         """
         Ensure the 'steps' table exists in the database.
@@ -1436,22 +1487,31 @@ class PersistenceManager(object):
     def get_validations(self) -> list[DocumentTaxonValidation]:
         return self._underlying_persistence.get_validations()
 
-    def get_external_data(self) -> dict:
+    def get_external_data(self, key="default") -> dict:
         """
         Gets the external data object associated with this document
 
         :return: dict of the external data
         """
-        return self._underlying_persistence.get_external_data()
+        return self._underlying_persistence.get_external_data(key)
+
+    def get_external_data_keys(self) -> List[str]:
+        """
+        Gets all keys under which external data is stored.
+
+        Returns:
+            List[str]: A list of all keys that have external data stored.
+        """
+        return self._underlying_persistence.get_external_data_keys()
 
-    def set_external_data(self, external_data:dict):
+    def set_external_data(self, external_data:dict, key="default"):
         """
         Sets the external data for this document
 
         :param external_data: dict representing the external data, must be JSON serializable
         :return:
         """
-        self._underlying_persistence.set_external_data(external_data)
+        self._underlying_persistence.set_external_data(external_data, key)
 
     def get_nodes_by_type(self, node_type: str) -> List[ContentNode]:
         """

{kodexa-7.0.12399293688.dist-info → kodexa-7.4.412416252968.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kodexa
-Version: 7.0.12399293688
+Version: 7.4.412416252968
 Summary: Python SDK for the Kodexa Platform
 Author: Austin Redenbaugh
 Author-email: austin@kodexa.com

{kodexa-7.0.12399293688.dist-info → kodexa-7.4.412416252968.dist-info}/RECORD

@@ -11,9 +11,9 @@ kodexa/model/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 kodexa/model/entities/check_response.py,sha256=eqBHxO6G2OAziL3p9bHGI-oiPkAG82H6Choc8wyvtM4,3949
 kodexa/model/entities/product.py,sha256=ZDpHuBE_9FJ-klnkyBvTfPwYOqBkM1wraZMtHqNA8FQ,3526
 kodexa/model/entities/product_subscription.py,sha256=UcmWR-qgLfdV7VCtJNwzgkanoS8nBSL6ngVuxQUK1M8,3810
-kodexa/model/model.py,sha256=Bjy1n6_9kQLLch-wCUDpT31sTctE2kCGdi4cb1ptZN4,118647
+kodexa/model/model.py,sha256=qh1YUew3UgtjU0t4fAwSXYYuzQjXTOZWZkafyFp_w8M,118801
 kodexa/model/objects.py,sha256=4Oyjs6omlHfwziAK1m2tFk4jSnzN7lFdXACog07ed1c,185124
-kodexa/model/persistence.py,sha256=P4DmC9UdczmjJgXNeeTlhwKH9nSAdzYZOaDTyqaDPOA,69501
+kodexa/model/persistence.py,sha256=ph6SSfyqBLkQoQAMeYNnKLP7tTPmirYRbywkaqa_fF8,72032
 kodexa/model/utils.py,sha256=6R-3rFiW9irBwj0Mq5yhp7EDXkNUFaeFhr3bWmnlW4g,2961
 kodexa/pipeline/__init__.py,sha256=sA7f5D6qkdMrpp2xTIeefnrUBI6xxEEWostvxfX_1Cs,236
 kodexa/pipeline/pipeline.py,sha256=ZYpJAWcwV4YRK589DUhU0vXGQlkNSj4J2TsGbYqTLjo,25221
@@ -43,7 +43,7 @@ kodexa/testing/test_utils.py,sha256=v44p__gE7ia67W7WeHN2HBFCWSCUrCZt7G4xBNCmwf8,
 kodexa/training/__init__.py,sha256=xs2L62YpRkIRfslQwtQZ5Yxjhm7sLzX2TrVX6EuBnZQ,52
 kodexa/training/train_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kodexa/utils/__init__.py,sha256=Pnim1o9_db5YEnNvDTxpM7HG-qTlL6n8JwFwOafU9wo,5928
-kodexa-7.0.12399293688.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-kodexa-7.0.12399293688.dist-info/METADATA,sha256=oQ8cDBBYml0HvYWVGK-klGpt_kpMzPARlO5JY0l0wdY,3527
-kodexa-7.0.12399293688.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-kodexa-7.0.12399293688.dist-info/RECORD,,
+kodexa-7.4.412416252968.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+kodexa-7.4.412416252968.dist-info/METADATA,sha256=kCmpaHdD1r67dKPNiNLSPSMW_DLAm_duFEEOiHU22zI,3528
+kodexa-7.4.412416252968.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+kodexa-7.4.412416252968.dist-info/RECORD,,