kodexa 6.0.186__tar.gz → 6.0.192a0__tar.gz

{kodexa-6.0.186 → kodexa-6.0.192a0}/PKG-INFO

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

{kodexa-6.0.186 → kodexa-6.0.192a0}/kodexa/model/model.py

@@ -79,7 +79,7 @@ class Tag(Dict):
         """A string representing the value that was labelled in the node"""
         self.data: Optional[Any] = data
         """Any data object (JSON serializable) that you wish to associate with the label"""
-        self.uuid: Optional[str] = uuid
+        self.uuid: Optional[str] = uuid or str(uuid.uuid4())
         """The UUID for this tag instance, this allows tags that are on different content nodes to be related through the same UUID"""
         self.confidence: Optional[float] = confidence
         """The confidence of the tag in a range of 0-1"""
@@ -1536,7 +1536,8 @@ class ContentNode(object):
             if not node:
                 if (traverse == traverse.ALL or traverse == traverse.PARENT) and self.get_parent().get_parent():
                     # can now traverse content-areas.. can add traversal of pages if needed, but don't think the scenario exists.
-                    potential_next_node = self.get_parent().get_parent().get_children()[self.get_parent().index + 1].get_children()[0]
+                    potential_next_node = \
+                        self.get_parent().get_parent().get_children()[self.get_parent().index + 1].get_children()[0]
                     if potential_next_node:
                         return potential_next_node
                 return node
@@ -1757,6 +1758,9 @@ class Document(object):
         self.classes: List[ContentClassification] = []
         """A list of the content classifications associated at the document level"""
 
+        self.tag_instances: List[TagInstance] = []
+        """A list of tag instances that contains a set of tag that has a set of nodes"""
+
         # Start persistence layer
         from kodexa.model import PersistenceManager
 
@@ -1765,6 +1769,36 @@ class Document(object):
                                                                                    delete_on_close=delete_on_close)
         self._persistence_layer.initialize()
 
+    def add_tag_instance(self, tag_to_apply, node_list: List[ContentNode]):
+        """
+            This will create a group of a tag with indexes
+        :param tag: name of the tag
+        :param node_indices: contains the list of index of a node
+        :return:
+        """
+        # For each node in the list create/update a feature
+        tag = Tag()
+        for node in node_list:
+            node.add_feature('tag', tag_to_apply, Tag)
+        # Tag Object
+        tag_instance = TagInstance(tag, node_list)
+        self.tag_instances.append(tag_instance)
+
+    def update_tag_instance(self, tag_uuid):
+        for tag_instance in self.tag_instances:
+            if tag_instance.tag.uuid == tag_uuid:
+                # Update attributes of a Tag
+                for node in tag_instance.nodes:
+                    node.get_tag(tag_instance.tag.value, tag_uuid=tag_instance.tag.uuid)
+
+    def get_tag_instance(self, tag):
+        """
+            Get the tag instance based on the tag itself
+        :param tag: name of the tag
+        :return: a list of tag instance
+        """
+        return [tag_instance for tag_instance in self.tag_instances if tag_instance.tag == tag]
+
     def get_persistence(self):
         return self._persistence_layer
 
@@ -2271,6 +2305,15 @@ class Document(object):
         return self.labels
 
 
+class TagInstance:
+    def __init__(self, tag: Tag, nodes):
+        self.tag = tag
+        self.nodes = nodes
+
+    def add_node(self, nodes: List[ContentNode]):
+        self.nodes.extend(nodes)
+
+
 class ContentObjectReference:
     """ """
 

{kodexa-6.0.186 → kodexa-6.0.192a0}/kodexa/platform/client.py

@@ -258,6 +258,35 @@ class ComponentEndpoint(ClientEndpoint, OrganizationOwned):
             return None
         return component_page.content[0]
 
+    def stream_list(self, query="*", page=1, page_size=10, sort=None, filters: List[str] = None):
+        url = f"/api/{self.get_type()}/{self.organization.slug}"
+
+        params = {"query": requests.utils.quote(query),
+                  "page": page,
+                  "pageSize": page_size}
+
+        if sort is not None:
+            params["sort"] = sort
+
+        if filters is not None:
+            params["legacyFilter"] = True
+            params["filter"] = filters
+
+        while True:
+            list_response = self.client.get(url, params=params)
+
+            # If there are no more results, exit the loop
+            if not list_response.json()["content"]:
+                break
+
+            # Yield each endpoint in the current page
+            for endpoint in self.get_page_class(list_response.json()).parse_obj(list_response.json()).set_client(
+                    self.client).to_endpoints():
+                yield endpoint
+
+            # Move to the next page
+            params["page"] += 1
+
     def list(self, query="*", page=1, page_size=10, sort=None, filters: List[str] = None):
         url = f"/api/{self.get_type()}/{self.organization.slug}"
 
@@ -987,6 +1016,28 @@ class ProjectsEndpoint(EntitiesEndpoint):
             return ProjectEndpoint.parse_obj(get_response.json()['content'][0]).set_client(self.client)
         return None
 
+    def stream_query(self, query: str = "*", sort=None):
+        """
+            Stream the query for the project endpoints
+        :param query: the query to run
+        :param sort: sorting order of the query
+        :return:
+            A generator of the project endpoints
+        """
+        page_size = 5
+        page = 1
+
+        if not sort:
+            sort = "id"
+
+        while True:
+            page_response = self.query(query=query, page=page, page_size=page_size, sort=sort)
+            if not page_response.content:
+                break
+            for project_endpoint in page_response.content:
+                yield project_endpoint
+            page += 1
+
     def query(self, query: str = "*", page: int = 1, page_size: int = 100, sort=None) -> Optional[PageProjectEndpoint]:
         params = {
             'page': page,
@@ -2004,6 +2055,28 @@ class DocumentStoreEndpoint(StoreEndpoint):
             f"/api/stores/{self.ref.replace(':', '/')}/families/{document_family_id}")
         return DocumentFamilyEndpoint.parse_obj(document_family_response.json()).set_client(self.client)
 
+    def stream_query(self, query: str = "*", sort=None):
+        """
+            Stream the query for the document family
+        :param query: the query to run
+        :param sort: sorting order of the query
+        :return:
+            A generator of the document families
+        """
+        page_size = 5
+        page = 1
+
+        if not sort:
+            sort = "id"
+
+        while True:
+            page_response = self.query(query=query, page=page, page_size=page_size, sort=sort)
+            if not page_response.content:
+                break
+            for document_family in page_response.content:
+                yield document_family
+            page += 1
+
     def query(self, query: str = "*", page: int = 1, page_size: int = 100, sort=None) -> PageDocumentFamilyEndpoint:
         params = {
             'page': page,
@@ -2019,6 +2092,28 @@ class DocumentStoreEndpoint(StoreEndpoint):
 
         return PageDocumentFamilyEndpoint.parse_obj(get_response.json()).set_client(self.client)
 
+    def stream_filter(self, filter_string: str = "", sort=None):
+        """
+            Stream the filter for the document family
+        :param query: the query to run
+        :param sort: sorting order of the query
+        :return:
+            A generator of the document families
+        """
+        page_size = 5
+        page = 1
+
+        if not sort:
+            sort = "id"
+
+        while True:
+            page_response = self.filter(filter_string=filter_string, page=page, page_size=page_size, sort=sort)
+            if not page_response.content:
+                break
+            for document_family in page_response.content:
+                yield document_family
+            page += 1
+
     def filter(self, filter_string: str = "", page: int = 1, page_size: int = 100,
                sort=None) -> PageDocumentFamilyEndpoint:
         params = {

{kodexa-6.0.186 → kodexa-6.0.192a0}/pyproject.toml

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

{kodexa-6.0.186 → kodexa-6.0.192a0}/setup.py

@@ -37,7 +37,7 @@ install_requires = \
 
 setup_kwargs = {
     'name': 'kodexa',
-    'version': '6.0.186',
+    'version': '6.0.192a0',
     'description': 'Python SDK for the Kodexa Platform',
     'long_description': '# Kodexa\n\n[![Build and Package with Poetry](https://github.com/kodexa-ai/kodexa/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/kodexa-ai/kodexa/actions/workflows/main.yml)\n\n![img.png](https://docs.kodexa.com/img.png)\n\nKodexa is a platform for building intelligent document processing pipelines. It is a set of tools and services that\nallow you to build a pipeline that can take a document, extract the content, and then process it to extract the\ninformation you need.\n\nIt is built on a set of core principles:\n\n* **Document Centric** - Kodexa is built around the idea of a document. A document is a collection of content\n  nodes that are connected together. This is a powerful model that allows you to build pipelines that can\n  extract content from a wide range of sources.\n\n* **Pipeline Oriented** - Kodexa is built around the idea of a pipeline. A pipeline is a series of steps that\n  can be executed on a document. This allows you to build a pipeline that can extract content from a wide range\n  of sources.\n\n* **Extensible** - Kodexa is built around the idea of a pipeline. A pipeline is a series of steps that can be executed\n  on a document. This allows you to build a pipeline that can extract content from a wide range of sources.\n\n* **Label Driven** - Kodexa focuses on the idea of labels. Labels are a way to identify content within a document\n  and then use that content to drive the processing of the document.\n\n# Python SDK\n\nThis repository contains the Python SDK for Kodexa. The SDK is the primary way to interact with Kodexa. It allows you to\ndefine actions, models, and pipelines that can be executed on Kodexa. It also includes a complete SDK client for\nworking with a Kodexa platform instance.\n\n## Documentation & Examples\n\nDocumentation is available at the [Kodexa Documentation Portal](https://docs.kodexa.com)\n\n## Current Development\n\nThe main branch is 6.0 which is a production release.\n\n## Set-up\n\nWe use poetry to manage our dependencies, so you can install them with:\n\n    poetry install\n\nYou can then run the tests with:\n\n    poetry run pytest\n\n# Contributing\n\nWe welcome contributions to the Kodexa platform. Please see our [contributing guide](CONTRIBUTING.md) for more details.\n\n# License\n\nApache 2.0\n',
     'author': 'Austin Redenbaugh',