kodexa 7.0.12399109365__tar.gz → 7.4.412416252968__tar.gz

{kodexa-7.0.12399109365 → kodexa-7.4.412416252968}/PKG-INFO

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

{kodexa-7.0.12399109365 → kodexa-7.4.412416252968}/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-7.0.12399109365 → kodexa-7.4.412416252968}/kodexa/model/persistence.py

@@ -111,9 +111,10 @@ class SqliteDocumentPersistence(object):
 
         self.cursor = self.connection.cursor()
         self.cursor.execute("PRAGMA journal_mode=OFF")
-        self.cursor.execute("pragma temp_store = memory")
-        self.cursor.execute("pragma mmap_size = 30000000000")
-        self.cursor.execute("pragma cache_size = 10000")  # Set the cache size to 10,000 pages
+        self.cursor.execute("PRAGMA temp_store=MEMORY")
+        self.cursor.execute("PRAGMA mmap_size=30000000000")
+        self.cursor.execute("PRAGMA cache_size=10000")
+        self.cursor.execute("PRAGMA page_size=4096")
 
         try:
             # We need to populate node_type_id_by_name
@@ -865,10 +866,11 @@ class SqliteDocumentPersistence(object):
         self.connection.commit()
         self.cursor.execute("VACUUM")
         self.cursor = self.connection.cursor()
-        self.cursor.execute("pragma journal_mode=OFF")
-        self.cursor.execute("pragma temp_store = memory")
-        self.cursor.execute("pragma mmap_size = 30000000000")
-        self.cursor.execute("pragma cache_size = 10000")  # Set the cache size to 10,000 pages
+        self.cursor.execute("PRAGMA journal_mode=OFF")
+        self.cursor.execute("PRAGMA temp_store=MEMORY")
+        self.cursor.execute("PRAGMA mmap_size=30000000000")
+        self.cursor.execute("PRAGMA cache_size=10000")
+        self.cursor.execute("PRAGMA page_size=4096")
 
     def dump_in_memory_db_to_file(self):
         # Connect to a new or existing database file
@@ -1154,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.
@@ -1211,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.
@@ -1434,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.12399109365 → kodexa-7.4.412416252968}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "kodexa"
-version = "7.0.012399109365"
+version = "7.4.412416252968"
 description = "Python SDK for the Kodexa Platform"
 authors = ["Austin Redenbaugh <austin@kodexa.com>", "Philip Dodds <philip@kodexa.com>", "Romar Cablao <rcablao@kodexa.com>", "Amadea Paula Dodds <amadeapaula@kodexa.com>"]
 readme = "README.md"
@@ -14,7 +14,7 @@ classifiers = [
     'Intended Audience :: Developers',
     'Topic :: Software Development :: Libraries',
     '''License :: OSI Approved :: Apache Software License''', # noqa
-    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
 ]
 
 [tool.poetry.dependencies]