kodexa 7.4.418502378964__tar.gz → 7.4.418571517744__tar.gz

{kodexa-7.4.418502378964 → kodexa-7.4.418571517744}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodexa
-Version: 7.4.418502378964
+Version: 7.4.418571517744
 Summary: Python SDK for the Kodexa Platform
 License-File: LICENSE
 Author: Austin Redenbaugh

{kodexa-7.4.418502378964 → kodexa-7.4.418571517744}/kodexa/model/model.py

@@ -14,7 +14,7 @@ import deepdiff
 import msgpack
 from pydantic import BaseModel, ConfigDict, Field
 
-from kodexa.model.objects import ContentObject, FeatureSet, DocumentTaxonValidation
+from kodexa.model.objects import ContentObject, FeatureSet, DocumentTaxonValidation, KnowledgeItem
 
 
 class Ref:
@@ -2503,6 +2503,12 @@ class Document(object):
     def set_steps(self, steps: list[ProcessingStep]):
         self._persistence_layer.set_steps(steps)
 
+    def get_knowledge(self) -> list[KnowledgeItem]:
+        return self._persistence_layer.get_knowledge()
+
+    def set_knowledge(self, knowledge: list[KnowledgeItem]):
+        self._persistence_layer.set_knowledge(knowledge)
+
     def replace_exceptions(self, exceptions: List[ContentException]):
         self._persistence_layer.replace_exceptions(exceptions)
 

{kodexa-7.4.418502378964 → kodexa-7.4.418571517744}/kodexa/model/objects.py

@@ -6464,6 +6464,215 @@ class Note(BaseModel):
     note_properties: Optional[Dict[str, str]] = Field(default_factory=dict, alias="noteProperties")
 
 
+# Knowledge Domain Models
+
+class KnowledgeSetStatus(str, Enum):
+    """Status of a KnowledgeSet lifecycle"""
+    PENDING_REVIEW = "PENDING_REVIEW"
+    IN_REVIEW = "IN_REVIEW"
+    ACTIVE = "ACTIVE"
+    ON_HOLD = "ON_HOLD"
+    ARCHIVED = "ARCHIVED"
+
+
+class KnowledgeFeatureType(BaseModel):
+    """Defines types of knowledge features"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    id: Optional[str] = Field(None, description="Unique identifier")
+    uuid: Optional[str] = None
+    name: str = Field(..., description="Feature type name")
+    slug: str = Field(..., description="URL-safe identifier")
+    description: Optional[str] = Field(None, description="Type description")
+    color: Optional[str] = Field(None, description="UI color code")
+    icon: Optional[str] = Field(None, description="Icon identifier")
+    label_json_path: Optional[str] = Field(None, alias="labelJsonPath", description="JSON path for label extraction")
+    options: Optional[List[Dict[str, Any]]] = Field(default_factory=list, description="Configuration options")
+    organization: Optional[Dict[str, Any]] = Field(None, description="Organization reference")
+    active: bool = Field(True, description="Is feature type active")
+    created_on: Optional[StandardDateTime] = Field(None, alias="createdOn")
+    updated_on: Optional[StandardDateTime] = Field(None, alias="updatedOn")
+
+
+class KnowledgeFeature(BaseModel):
+    """Represents a knowledge feature linking items and document families"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    id: Optional[str] = Field(None, description="Unique identifier")
+    uuid: Optional[str] = None
+    properties: Dict[str, Any] = Field(default_factory=dict, description="Feature properties (JSON map)")
+    feature_type: Optional[KnowledgeFeatureType] = Field(None, alias="featureType", description="Type of this feature")
+    organization: Optional[Dict[str, Any]] = Field(None, description="Organization reference")
+    active: bool = Field(True, description="Is feature active")
+    search_text: Optional[str] = Field(None, alias="searchText", description="Generated search text from properties")
+    created_on: Optional[StandardDateTime] = Field(None, alias="createdOn")
+    updated_on: Optional[StandardDateTime] = Field(None, alias="updatedOn")
+
+
+class KnowledgeItemType(BaseModel):
+    """Defines types of knowledge items"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    id: Optional[str] = Field(None, description="Unique identifier")
+    uuid: Optional[str] = None
+    name: str = Field(..., description="Item type name")
+    slug: str = Field(..., description="URL-safe identifier")
+    description: Optional[str] = Field(None, description="Type description")
+    options: Optional[List[Dict[str, Any]]] = Field(default_factory=list, description="Configuration options")
+    organization: Optional[Dict[str, Any]] = Field(None, description="Organization reference")
+    created_on: Optional[StandardDateTime] = Field(None, alias="createdOn")
+    updated_on: Optional[StandardDateTime] = Field(None, alias="updatedOn")
+
+
+class KnowledgeItem(BaseModel):
+    """Represents a reusable knowledge unit"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    id: Optional[str] = Field(None, description="Unique identifier")
+    uuid: Optional[str] = None
+    title: Optional[str] = Field(None, description="Item title")
+    description: Optional[str] = Field(None, description="Item description")
+    knowledge_item_type: Optional[KnowledgeItemType] = Field(None, alias="knowledgeItemType", description="Type of this item")
+    knowledge_set_id: Optional[str] = Field(None, alias="knowledgeSetId", description="Parent set ID if in a set")
+    properties: Dict[str, Any] = Field(default_factory=dict, description="Item properties (JSON map)")
+    sequence_order: Optional[int] = Field(None, alias="sequenceOrder", description="Order within parent set")
+    active: bool = Field(True, description="Is item active")
+    search_text: Optional[str] = Field(None, alias="searchText", description="Generated search text from title/description")
+    created_on: Optional[StandardDateTime] = Field(None, alias="createdOn")
+    updated_on: Optional[StandardDateTime] = Field(None, alias="updatedOn")
+
+
+class KnowledgeSet(BaseModel):
+    """Composite set of knowledge items with feature matching"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    id: Optional[str] = Field(None, description="Unique identifier")
+    uuid: Optional[str] = None
+    name: str = Field(..., description="Set name")
+    description: Optional[str] = Field(None, description="Set description")
+    set_type: Optional[str] = Field(None, alias="setType", description="Type classification of the set")
+    knowledge_items: List[KnowledgeItem] = Field(default_factory=list, alias="knowledgeItems", description="Items in this set (ordered by sequenceOrder)")
+    features: List[KnowledgeFeature] = Field(default_factory=list, description="Features associated with this set")
+    organization: Optional[Dict[str, Any]] = Field(None, description="Organization reference")
+    project: Optional[Dict[str, Any]] = Field(None, description="Project reference")
+    status: KnowledgeSetStatus = Field(KnowledgeSetStatus.PENDING_REVIEW, description="Lifecycle status")
+    active: bool = Field(False, description="Is set active")
+    search_text: Optional[str] = Field(None, alias="searchText", description="Generated search text")
+    created_on: Optional[StandardDateTime] = Field(None, alias="createdOn")
+    updated_on: Optional[StandardDateTime] = Field(None, alias="updatedOn")
+
+
+# Page models for pagination
+class PageKnowledgeFeatureType(BaseModel):
+    """Paginated response for KnowledgeFeatureType"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+    content: List[KnowledgeFeatureType] = Field(default_factory=list)
+    total_elements: Optional[int] = Field(None, alias="totalElements")
+    total_pages: Optional[int] = Field(None, alias="totalPages")
+    number: Optional[int] = None
+    size: Optional[int] = None
+    first: Optional[bool] = None
+    last: Optional[bool] = None
+
+
+class PageKnowledgeFeature(BaseModel):
+    """Paginated response for KnowledgeFeature"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+    content: List[KnowledgeFeature] = Field(default_factory=list)
+    total_elements: Optional[int] = Field(None, alias="totalElements")
+    total_pages: Optional[int] = Field(None, alias="totalPages")
+    number: Optional[int] = None
+    size: Optional[int] = None
+    first: Optional[bool] = None
+    last: Optional[bool] = None
+
+
+class PageKnowledgeItemType(BaseModel):
+    """Paginated response for KnowledgeItemType"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+    content: List[KnowledgeItemType] = Field(default_factory=list)
+    total_elements: Optional[int] = Field(None, alias="totalElements")
+    total_pages: Optional[int] = Field(None, alias="totalPages")
+    number: Optional[int] = None
+    size: Optional[int] = None
+    first: Optional[bool] = None
+    last: Optional[bool] = None
+
+
+class PageKnowledgeItem(BaseModel):
+    """Paginated response for KnowledgeItem"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+    content: List[KnowledgeItem] = Field(default_factory=list)
+    total_elements: Optional[int] = Field(None, alias="totalElements")
+    total_pages: Optional[int] = Field(None, alias="totalPages")
+    number: Optional[int] = None
+    size: Optional[int] = None
+    first: Optional[bool] = None
+    last: Optional[bool] = None
+
+
+class PageKnowledgeSet(BaseModel):
+    """Paginated response for KnowledgeSet"""
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+    content: List[KnowledgeSet] = Field(default_factory=list)
+    total_elements: Optional[int] = Field(None, alias="totalElements")
+    total_pages: Optional[int] = Field(None, alias="totalPages")
+    number: Optional[int] = None
+    size: Optional[int] = None
+    first: Optional[bool] = None
+    last: Optional[bool] = None
+
+
 ThrowableProblem.model_rebuild()
 Option.model_rebuild()
 Taxon.model_rebuild()
@@ -6523,3 +6732,13 @@ MessageFeedbackResponse.model_rebuild()
 MessageFeedbackOption.model_rebuild()
 Note.model_rebuild()
 PageNote.model_rebuild()
+KnowledgeFeatureType.model_rebuild()
+KnowledgeFeature.model_rebuild()
+KnowledgeItemType.model_rebuild()
+KnowledgeItem.model_rebuild()
+KnowledgeSet.model_rebuild()
+PageKnowledgeFeatureType.model_rebuild()
+PageKnowledgeFeature.model_rebuild()
+PageKnowledgeItemType.model_rebuild()
+PageKnowledgeItem.model_rebuild()
+PageKnowledgeSet.model_rebuild()

{kodexa-7.4.418502378964 → kodexa-7.4.418571517744}/kodexa/model/persistence.py

@@ -1369,6 +1369,51 @@ class SqliteDocumentPersistence(object):
             return [ProcessingStep(**step) for step in unpacked_data]
         return []
 
+    def __ensure_knowledge_table_exists(self):
+        """
+        Ensure the 'knowledge' table exists in the database.
+        Creates the table if it does not exist.
+        """
+        self.cursor.execute("""
+                CREATE TABLE IF NOT EXISTS knowledge (
+                    obj BLOB
+                )
+            """)
+
+        # Check if the table has any rows, if not, insert an initial empty row
+        result = self.cursor.execute("SELECT COUNT(*) FROM knowledge").fetchone()
+        if result[0] == 0:
+            self.cursor.execute("INSERT INTO knowledge (obj) VALUES (?)", [sqlite3.Binary(msgpack.packb([]))])
+
+    def set_knowledge(self, knowledge: List):
+        """
+        Sets the knowledge items for the document.
+
+        Args:
+            knowledge (List): A list of KnowledgeItem objects to store.
+        """
+        from kodexa.model.objects import KnowledgeItem
+        self.__ensure_knowledge_table_exists()
+        serialized_knowledge = [item.model_dump(by_alias=True) for item in knowledge]
+        packed_data = sqlite3.Binary(msgpack.packb(serialized_knowledge))
+        self.cursor.execute("UPDATE knowledge SET obj = ? WHERE rowid = 1", [packed_data])
+        self.connection.commit()
+
+    def get_knowledge(self) -> List:
+        """
+        Gets the knowledge items associated with this document.
+
+        Returns:
+            List: A list of KnowledgeItem objects.
+        """
+        from kodexa.model.objects import KnowledgeItem
+        self.__ensure_knowledge_table_exists()
+        result = self.cursor.execute("SELECT obj FROM knowledge WHERE rowid = 1").fetchone()
+        if result and result[0]:
+            unpacked_data = msgpack.unpackb(result[0])
+            return [KnowledgeItem(**item) for item in unpacked_data]
+        return []
+
 
 class SimpleObjectCache(object):
     """
@@ -1518,6 +1563,22 @@ class PersistenceManager(object):
     def set_steps(self, steps: list[ProcessingStep]):
         self._underlying_persistence.set_steps(steps)
 
+    def get_knowledge(self) -> list:
+        """
+        Gets the knowledge items for this document
+
+        :return: list of KnowledgeItem objects
+        """
+        return self._underlying_persistence.get_knowledge()
+
+    def set_knowledge(self, knowledge: list):
+        """
+        Sets the knowledge items for this document
+
+        :param knowledge: list of KnowledgeItem objects
+        """
+        self._underlying_persistence.set_knowledge(knowledge)
+
     def set_validations(self, validations: list[DocumentTaxonValidation]):
         self._underlying_persistence.set_validations(validations)
 

{kodexa-7.4.418502378964 → kodexa-7.4.418571517744}/kodexa/platform/client.py

@@ -108,6 +108,17 @@ from kodexa.model.objects import (
     PageTaskTag,
     Note,
     PageNote,
+    KnowledgeFeatureType,
+    KnowledgeFeature,
+    KnowledgeItemType,
+    KnowledgeItem,
+    KnowledgeSet,
+    KnowledgeSetStatus,
+    PageKnowledgeFeatureType,
+    PageKnowledgeFeature,
+    PageKnowledgeItemType,
+    PageKnowledgeItem,
+    PageKnowledgeSet,
 )
 
 logger = logging.getLogger()
@@ -1467,6 +1478,158 @@ class PageNoteEndpoint(PageNote, PageEndpoint):
         return "notes"
 
 
+# Knowledge Domain Endpoints
+
+class KnowledgeFeatureTypeEndpoint(EntityEndpoint, KnowledgeFeatureType):
+    """
+    Represents a knowledge feature type endpoint.
+    """
+    def get_type(self) -> str:
+        return "knowledge-feature-types"
+
+
+class KnowledgeFeatureTypesEndpoint(EntitiesEndpoint):
+    """
+    Represents knowledge feature types endpoints.
+    """
+    def get_type(self) -> str:
+        return "knowledge-feature-types"
+
+    def get_instance_class(self, object_dict=None):
+        return KnowledgeFeatureTypeEndpoint
+
+    def get_page_class(self, object_dict=None):
+        return PageKnowledgeFeatureTypeEndpoint
+
+
+class PageKnowledgeFeatureTypeEndpoint(PageKnowledgeFeatureType, PageEndpoint):
+    """
+    Represents a page knowledge feature type endpoint.
+    """
+    def get_type(self) -> Optional[str]:
+        return "knowledge-feature-types"
+
+
+class KnowledgeFeatureEndpoint(EntityEndpoint, KnowledgeFeature):
+    """
+    Represents a knowledge feature endpoint.
+    """
+    def get_type(self) -> str:
+        return "knowledge-features"
+
+
+class KnowledgeFeaturesEndpoint(EntitiesEndpoint):
+    """
+    Represents knowledge features endpoints.
+    """
+    def get_type(self) -> str:
+        return "knowledge-features"
+
+    def get_instance_class(self, object_dict=None):
+        return KnowledgeFeatureEndpoint
+
+    def get_page_class(self, object_dict=None):
+        return PageKnowledgeFeatureEndpoint
+
+
+class PageKnowledgeFeatureEndpoint(PageKnowledgeFeature, PageEndpoint):
+    """
+    Represents a page knowledge feature endpoint.
+    """
+    def get_type(self) -> Optional[str]:
+        return "knowledge-features"
+
+
+class KnowledgeItemTypeEndpoint(EntityEndpoint, KnowledgeItemType):
+    """
+    Represents a knowledge item type endpoint.
+    """
+    def get_type(self) -> str:
+        return "knowledge-item-types"
+
+
+class KnowledgeItemTypesEndpoint(EntitiesEndpoint):
+    """
+    Represents knowledge item types endpoints.
+    """
+    def get_type(self) -> str:
+        return "knowledge-item-types"
+
+    def get_instance_class(self, object_dict=None):
+        return KnowledgeItemTypeEndpoint
+
+    def get_page_class(self, object_dict=None):
+        return PageKnowledgeItemTypeEndpoint
+
+
+class PageKnowledgeItemTypeEndpoint(PageKnowledgeItemType, PageEndpoint):
+    """
+    Represents a page knowledge item type endpoint.
+    """
+    def get_type(self) -> Optional[str]:
+        return "knowledge-item-types"
+
+
+class KnowledgeItemEndpoint(EntityEndpoint, KnowledgeItem):
+    """
+    Represents a knowledge item endpoint.
+    """
+    def get_type(self) -> str:
+        return "knowledge-items"
+
+
+class KnowledgeItemsEndpoint(EntitiesEndpoint):
+    """
+    Represents knowledge items endpoints.
+    """
+    def get_type(self) -> str:
+        return "knowledge-items"
+
+    def get_instance_class(self, object_dict=None):
+        return KnowledgeItemEndpoint
+
+    def get_page_class(self, object_dict=None):
+        return PageKnowledgeItemEndpoint
+
+
+class PageKnowledgeItemEndpoint(PageKnowledgeItem, PageEndpoint):
+    """
+    Represents a page knowledge item endpoint.
+    """
+    def get_type(self) -> Optional[str]:
+        return "knowledge-items"
+
+
+class KnowledgeSetEndpoint(EntityEndpoint, KnowledgeSet):
+    """
+    Represents a knowledge set endpoint.
+    """
+    def get_type(self) -> str:
+        return "knowledge-sets"
+
+
+class KnowledgeSetsEndpoint(EntitiesEndpoint):
+    """
+    Represents knowledge sets endpoints.
+    """
+    def get_type(self) -> str:
+        return "knowledge-sets"
+
+    def get_instance_class(self, object_dict=None):
+        return KnowledgeSetEndpoint
+
+    def get_page_class(self, object_dict=None):
+        return PageKnowledgeSetEndpoint
+
+
+class PageKnowledgeSetEndpoint(PageKnowledgeSet, PageEndpoint):
+    """
+    Represents a page knowledge set endpoint.
+    """
+    def get_type(self) -> Optional[str]:
+        return "knowledge-sets"
+
+
 class PageTaskTemplateEndpoint(PageTask, PageEndpoint):
     def get_type(self) -> Optional[str]:
         return "taskTemplate"
@@ -6848,6 +7011,11 @@ class KodexaClient:
         users (UsersEndpoint): An endpoint for users.
         workspaces (WorkspacesEndpoint): An endpoint for workspaces.
         notes (NotesEndpoint): An endpoint for notes.
+        knowledge_feature_types (KnowledgeFeatureTypesEndpoint): An endpoint for knowledge feature types.
+        knowledge_features (KnowledgeFeaturesEndpoint): An endpoint for knowledge features.
+        knowledge_item_types (KnowledgeItemTypesEndpoint): An endpoint for knowledge item types.
+        knowledge_items (KnowledgeItemsEndpoint): An endpoint for knowledge items.
+        knowledge_sets (KnowledgeSetsEndpoint): An endpoint for knowledge sets.
     """
 
     def __init__(self, url=None, access_token=None, profile=None):
@@ -6879,6 +7047,11 @@ class KodexaClient:
         self.workspaces = WorkspacesEndpoint(self)
         self.data_exceptions = DataExceptionsEndpoint(self)
         self.notes = NotesEndpoint(self)
+        self.knowledge_feature_types = KnowledgeFeatureTypesEndpoint(self)
+        self.knowledge_features = KnowledgeFeaturesEndpoint(self)
+        self.knowledge_item_types = KnowledgeItemTypesEndpoint(self)
+        self.knowledge_items = KnowledgeItemsEndpoint(self)
+        self.knowledge_sets = KnowledgeSetsEndpoint(self)
         self.model_costs = ModelCostsEndpoint(self)
 
     @staticmethod

{kodexa-7.4.418502378964 → kodexa-7.4.418571517744}/pyproject.toml

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