kodexa 7.0.10217227753__py3-none-any.whl → 7.0.10350737552__py3-none-any.whl

kodexa/model/model.py

@@ -12,7 +12,7 @@ from typing import Any, List, Optional
 from addict import Dict
 import deepdiff
 import msgpack
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 from kodexa.model.objects import ContentObject, FeatureSet
 
@@ -2369,6 +2369,55 @@ class FeatureSetDiff:
         return node
 
 
+class ProcessingStep(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    name: str
+    metadata: dict = Field(default_factory=lambda: {})
+    children: List['ProcessingStep'] = Field(default_factory=list)
+    parents: List['ProcessingStep'] = Field(default_factory=list)
+
+    def add_child(self, child_step: 'ProcessingStep'):
+        self.children.append(child_step)
+        child_step.parents.append(self)
+
+    @staticmethod
+    def merge_with(*other_steps: 'ProcessingStep') -> 'ProcessingStep':
+        merged_step = ProcessingStep(name=f"Merged({', '.join(step.name for step in other_steps)})")
+        for step in other_steps:
+            step.children.append(merged_step)
+            merged_step.parents.append(step)
+        return merged_step
+
+    class Config:
+        arbitrary_types_allowed = True
+        json_encoders = {
+            'ProcessingStep': lambda step: step.to_dict()
+        }
+
+    def to_dict(self, seen=None):
+        if seen is None:
+            seen = set()
+
+        # Avoid circular references by skipping already seen objects
+        if self.id in seen:
+            return {'id': self.id, 'name': self.name}
+
+        seen.add(self.id)
+
+        return {
+            'id': self.id,
+            'name': self.name,
+            'children': [child.to_dict(seen) for child in self.children],
+            'parents': [{'id': parent.id, 'name': parent.name} for parent in self.parents],  # or parent.to_dict(seen) if full structure is needed
+        }
+
+    def to_json(self):
+        return json.dumps(self.to_dict())
+
+    def __repr__(self):
+        return f"Step(id={self.id}, name={self.name})"
+
+
 class Document(object):
     """A Document is a collection of metadata and a set of content nodes."""
 
@@ -2384,6 +2433,18 @@ 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 set_external_data(self, external_data:dict):
+        return self._persistence_layer.set_external_data(external_data)
+
+    def get_steps(self) -> list[ProcessingStep]:
+        return self._persistence_layer.get_steps()
+
+    def set_steps(self, steps: list[ProcessingStep]):
+        self._persistence_layer.set_steps(steps)
+
     def replace_exceptions(self, exceptions: List[ContentException]):
         self._persistence_layer.replace_exceptions(exceptions)
 

kodexa/model/persistence.py

@@ -13,7 +13,7 @@ from kodexa.model.model import (
     DocumentMetadata,
     ContentFeature,
     ContentException,
-    ModelInsight,
+    ModelInsight, ProcessingStep,
 )
 
 logger = logging.getLogger()
@@ -1122,6 +1122,90 @@ 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 set_external_data(self, external_data: dict):
+        """
+        Sets the external data for the document.
+
+        Args:
+            external_data (dict): The external data to store, must be JSON serializable.
+        """
+        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.connection.commit()
+
+    def get_external_data(self) -> dict:
+        """
+        Gets the external data associated with this document.
+
+        Returns:
+            dict: The external data stored in the ed table.
+        """
+        self.__ensure_ed_table_exists()
+        result = self.cursor.execute("SELECT obj FROM ed WHERE rowid = 1").fetchone()
+        if result and result[0]:
+            return msgpack.unpackb(result[0])
+        return {}
+
+    def __ensure_steps_table_exists(self):
+        """
+        Ensure the 'steps' table exists in the database.
+        Creates the table if it does not exist.
+        """
+        self.cursor.execute("""
+                CREATE TABLE IF NOT EXISTS steps (
+                    obj BLOB
+                )
+            """)
+
+        # Check if the table has any rows, if not, insert an initial empty row
+        result = self.cursor.execute("SELECT COUNT(*) FROM steps").fetchone()
+        if result[0] == 0:
+            self.cursor.execute("INSERT INTO steps (obj) VALUES (?)", [sqlite3.Binary(msgpack.packb([]))])
+
+    def set_steps(self, steps: List[ProcessingStep]):
+        """
+        Sets the processing steps for the document.
+
+        Args:
+            steps (List[ProcessingStep]): A list of ProcessingStep objects to store.
+        """
+        self.__ensure_steps_table_exists()
+        serialized_steps = [step.to_dict() for step in steps]
+        packed_data = sqlite3.Binary(msgpack.packb(serialized_steps))
+        self.cursor.execute("UPDATE steps SET obj = ? WHERE rowid = 1", [packed_data])
+        self.connection.commit()
+
+    def get_steps(self) -> List[ProcessingStep]:
+        """
+        Gets the processing steps associated with this document.
+
+        Returns:
+            List[ProcessingStep]: A list of ProcessingStep objects.
+        """
+        self.__ensure_steps_table_exists()
+        result = self.cursor.execute("SELECT obj FROM steps WHERE rowid = 1").fetchone()
+        if result and result[0]:
+            unpacked_data = msgpack.unpackb(result[0])
+            return [ProcessingStep(**step) for step in unpacked_data]
+        return []
+
 
 class SimpleObjectCache(object):
     """
@@ -1260,6 +1344,34 @@ class PersistenceManager(object):
             document, filename, delete_on_close, inmemory=inmemory
         )
 
+    def get_steps(self) -> list[ProcessingStep]:
+        """
+        Gets the processing steps for this document
+
+        :return:
+        """
+        return self._underlying_persistence.get_steps()
+
+    def set_steps(self, steps: list[ProcessingStep]):
+        self._underlying_persistence.set_steps(steps)
+
+    def get_external_data(self) -> dict:
+        """
+        Gets the external data object associated with this document
+
+        :return: dict of the external data
+        """
+        return self._underlying_persistence.get_external_data()
+
+    def set_external_data(self, external_data:dict):
+        """
+        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)
+
     def get_nodes_by_type(self, node_type: str) -> List[ContentNode]:
         """
         Retrieves all nodes of a given type from the underlying persistence layer.

{kodexa-7.0.10217227753.dist-info → kodexa-7.0.10350737552.dist-info}/METADATA

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

{kodexa-7.0.10217227753.dist-info → kodexa-7.0.10350737552.dist-info}/RECORD

@@ -9,9 +9,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=BURhrOEVTTlKkDJho5CEFeLR9Dyq157mztlvbAdL1d4,115769
+kodexa/model/model.py,sha256=v9dUIWXtzRXFBg3UI2zpPql1oUP2bQpey5fKLRXjhsA,117857
 kodexa/model/objects.py,sha256=C4ERIaB0Avuf2FHIvEsyyO_HAjvDVXW_CB6-EEEhUtA,176751
-kodexa/model/persistence.py,sha256=sx5FwTSsWMdAZpAs0-6PqyULHkQyNQClApUKJZ-ly8M,62032
+kodexa/model/persistence.py,sha256=XJ4mi1dG1E1cOwbNjj9E9-_6kXsqKDjxVEJDAfI4rjo,66052
 kodexa/pipeline/__init__.py,sha256=sA7f5D6qkdMrpp2xTIeefnrUBI6xxEEWostvxfX_1Cs,236
 kodexa/pipeline/pipeline.py,sha256=ZYpJAWcwV4YRK589DUhU0vXGQlkNSj4J2TsGbYqTLjo,25221
 kodexa/platform/__init__.py,sha256=1O3oiWMg292NPL_NacKDnK1T3_R6cMorrPRue_9e-O4,216
@@ -39,7 +39,7 @@ kodexa/testing/test_components.py,sha256=g5lP-GY0nTHuH5cIEw45vIejEeBaWkPKQGHL36j
 kodexa/testing/test_utils.py,sha256=DrLCkHxdb6AbZ-X3WmTMbQmnVIm55VEBL8MjtUK9POs,14021
 kodexa/training/__init__.py,sha256=xs2L62YpRkIRfslQwtQZ5Yxjhm7sLzX2TrVX6EuBnZQ,52
 kodexa/training/train_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kodexa-7.0.10217227753.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-kodexa-7.0.10217227753.dist-info/METADATA,sha256=RqtKO6MqfpRacsb3dpza0ok4EfaSn5Qg5c4AzHsXCZs,3533
-kodexa-7.0.10217227753.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-kodexa-7.0.10217227753.dist-info/RECORD,,
+kodexa-7.0.10350737552.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+kodexa-7.0.10350737552.dist-info/METADATA,sha256=SFvyMuqsVbNSBZ7tal88dBHT4temLjiySjugrvxE2Bs,3533
+kodexa-7.0.10350737552.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+kodexa-7.0.10350737552.dist-info/RECORD,,