kodexa 7.0.10217227753__tar.gz → 7.0.10350737552__tar.gz

{kodexa-7.0.10217227753 → kodexa-7.0.10350737552}/PKG-INFO

@@ -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 → kodexa-7.0.10350737552}/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-7.0.10217227753 → kodexa-7.0.10350737552}/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 → kodexa-7.0.10350737552}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "kodexa"
-version = "7.0.010217227753"
+version = "7.0.010350737552"
 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"