kodexa 6.1.2a4891138870__tar.gz → 6.1.2a5059971029__tar.gz

{kodexa-6.1.2a4891138870 → kodexa-6.1.2a5059971029}/PKG-INFO

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

{kodexa-6.1.2a4891138870 → kodexa-6.1.2a5059971029}/kodexa/model/model.py

@@ -15,6 +15,7 @@ from addict import Dict
 
 from kodexa.model.base import KodexaBaseModel
 from kodexa.model.objects import ContentObject, FeatureSet
+import deepdiff
 
 
 class Ref:
@@ -1717,13 +1718,124 @@ class FeatureSetDiff:
     """
 
     def __init__(self, first_feature_set: FeatureSet, second_feature_set: FeatureSet):
-        self.first_feature_set = first_feature_set
-        self.second_feature_set = second_feature_set
+        self.first_feature_map = self.parse_feature_set(first_feature_set)
+        self.second_feature_map = self.parse_feature_set(second_feature_set)
+        self._differences = deepdiff.DeepDiff(self.first_feature_map, self.second_feature_map,
+                                              exclude_obj_callback=self.exclude_callback).to_dict()
+        self._changed_nodes = self.get_changed_nodes()
 
-    def diff(self):
-        # TODO Implement a deepdiff
+    def get_differences(self):
+        """
+        :return: Data dictionaries that contains the differences of two feature sets
+        """
+        if 'type_changes' in self._differences:
+            self._differences.pop('type_changes')
+
+        return self._differences
+
+    def get_changed_nodes(self):
+        """
+        :return: Data dictionary of added and removed nodes
+        """
+        return self._changed_nodes
+
+    def get_exclude_paths(self):
+        """
+        :return: List of paths to exclude
+        """
+        return ['shape', 'group_uuid', 'uuid', 'parent_group_uuid', 'single']
+
+    def exclude_callback(self, path, key):
+        """
+        Checks if the key is to be exluceded from the diff
+        :param path: contains the values of that key
+        :param key: The key of the data dictionary to compare
+        :return: boolean
+        """
+        if any(re.search(exclude_key, key) for exclude_key in self.get_exclude_paths()):
+            return True
+        else:
+            return False
+
+    def parse_feature_set(self, feature_set: FeatureSet):
+        """
+        :param feature_set: The feature set to be parsed
+        :return: Dictionary of feature with the key as the nodeUuid
+        """
+        return {feature.get('nodeUuid'): feature for feature in feature_set.node_features}
 
-        pass
+    def parsed_values_changed(self):
+        for key, value in self._differences.get('values_changed').items():
+            # Check if the old_value is stil in the second_feature_map. If it is remove the key
+            if key in self.second_feature_map.node_features:
+                self._differences.get('values_changed').remove(key)
+
+    def is_equal(self) -> bool:
+        """
+        Checks if the two feature set is equal to each other
+        :return: This returns a bool
+        """
+        return self._differences == {}
+
+    def get_changed_nodes(self):
+        """
+        :return: A list of nodes that were changed
+        """
+        if self.is_equal():
+            return []
+
+        # Check for new nodes added in the second_feature_map
+        new_added_nodes = []
+
+        # Checked for removed nodes in the first_feature_map
+        removed_nodes = []
+
+        # Checked for modified nodes
+        modified_nodes = []
+        for key, value in self._differences.get('values_changed').items():
+            modified_nodes.append(self.parsed_node_uuid(key))
+
+        # Merge unique nodeUuid of first_feature_map and second_feature_map
+        merged_node_uuids = set(self.first_feature_map.keys()).union(set(self.second_feature_map.keys()))
+        for node_uuid in merged_node_uuids:
+            if node_uuid not in self.first_feature_map:
+                new_added_nodes.append(node_uuid)
+            elif node_uuid not in self.second_feature_map:
+                removed_nodes.append(node_uuid)
+
+        return {
+            'new_added_nodes': new_added_nodes,
+            'removed_nodes': removed_nodes,
+            'existing_modified_nodes': modified_nodes
+        }
+
+    def get_difference_count(self):
+        """
+        :return: The total number of differences between the feature sets
+        """
+        return len(self._differences().keys())
+
+    def parsed_item_added(self):
+        item_added: Dict = self._differences.get('iterable_item_added')
+        if item_added:
+            return {}
+
+        for key, value in item_added.items():
+            node = self.parsed_node_uuid(key)
+            if node in self._changed_nodes['new_added_nodes']:
+                self._differences['iterable_item_added'][key]['details'] = f'Node: {node} was added'
+                continue
+
+            # if node in
+        return self.get_difference_count()
+
+    def parsed_node_uuid(self, key):
+        """
+        :param key: Key of data dictionary
+        :return: node uuid from the key
+        """
+        node = key.split("['")[1].split("']")[0]
+        return node
 
 
 class Document(object):
@@ -2321,6 +2433,8 @@ class Document(object):
                     feature_dict['name'] = feature.name
                     node_feature['features'].append(feature_dict)
 
+        return feature_set
+
     def get_all_tagged_nodes(self) -> List[ContentNode]:
         """
         Get all the tagged nodes in the document

{kodexa-6.1.2a4891138870 → kodexa-6.1.2a5059971029}/kodexa/platform/client.py

@@ -411,6 +411,27 @@ class EntitiesEndpoint:
         self.client: "KodexaClient" = client
         self.organization: Optional["OrganizationEndpoint"] = organization
 
+    def stream_list(self, query="*", sort=None, filters: List[str] = None):
+        """
+            Stream the list of resources
+        :param query:
+        :param sort:
+        :param filters:
+        :return:
+        """
+        page_size = 5
+        page = 1
+        if not sort:
+            sort = "id"
+
+        while True:
+            page_response = self.list(query=query, page=page, page_size=page_size, sort=sort, filters=filters)
+            if not page_response.content:
+                break
+            for resource in page_response.content:
+                yield resource
+            page += 1
+
     def list(self, query="*", page=1, page_size=10, sort=None, filters: List[str] = None):
         url = f"/api/{self.get_type()}"
 
@@ -2170,7 +2191,7 @@ class DocumentStoreEndpoint(StoreEndpoint):
 
         return PageDocumentFamilyEndpoint.parse_obj(get_response.json()).set_client(self.client)
 
-    def stream_filter(self, filter_string: str = "", sort=None):
+    def stream_filter(self, filter_string: str = "", sort=None, limit=None):
         """
             Stream the filter for the document family
         :param query: the query to run
@@ -2589,10 +2610,10 @@ class ExtractionEngineEndpoint:
 
 class KodexaClient:
 
-    def __init__(self, url=None, access_token=None):
+    def __init__(self, url=None, access_token=None, profile=None):
         from kodexa import KodexaPlatform
-        self.base_url = url if url is not None else KodexaPlatform.get_url()
-        self.access_token = access_token if access_token is not None else KodexaPlatform.get_access_token()
+        self.base_url = url if url is not None else KodexaPlatform.get_url(profile)
+        self.access_token = access_token if access_token is not None else KodexaPlatform.get_access_token(profile)
         self.organizations = OrganizationsEndpoint(self)
         self.projects = ProjectsEndpoint(self)
         self.workspaces = WorkspacesEndpoint(self)
@@ -2669,6 +2690,9 @@ class KodexaClient:
         headers = {"x-access-token": self.access_token}
         if files is None:
             headers["content-type"] = "application/json"
+        else:
+            headers["content-type"] = "multipart/form-data"
+
         response = requests.post(self.get_url(url), json=body, data=data, files=files, params=params,
                                  headers=headers)
         return process_response(response)
@@ -2679,6 +2703,7 @@ class KodexaClient:
             headers["content-type"] = "application/json"
         else:
             headers["content-type"] = "multipart/form-data"
+
         response = requests.put(self.get_url(url), json=body, data=data, files=files, params=params,
                                 headers=headers)
         return process_response(response)

{kodexa-6.1.2a4891138870 → kodexa-6.1.2a5059971029}/kodexa/platform/kodexa.py

@@ -34,7 +34,7 @@ logger = logging.getLogger()
 dirs = AppDirs("Kodexa", "Kodexa")
 
 
-def get_config():
+def get_config(profile=None):
     """Get the kodexa config object we use when you want to store your PAT locally
 
     :return: the config as a dict
@@ -47,9 +47,12 @@ def get_config():
     path = os.path.join(dirs.user_config_dir, '.kodexa.json')
     if os.path.exists(path):
         with open(path, 'r') as outfile:
-            return json.load(outfile)
+            kodexa_config = json.load(outfile)
+            if profile and profile not in kodexa_config:
+                kodexa_config[profile] = {'url': None, 'access_token': None}
+            return kodexa_config
     else:
-        return {'url': None, 'access_token': None}
+        return {'url': None, 'access_token': None} if not profile else {profile: {'url': None, 'access_token': None}}
 
 
 def save_config(config_obj):
@@ -244,7 +247,7 @@ class KodexaPlatform:
         return KodexaClient(KodexaPlatform.get_url(), KodexaPlatform.get_access_token())
 
     @staticmethod
-    def get_access_token() -> str:
+    def get_access_token(profile=None) -> str:
         """
         Returns the access token
 
@@ -253,12 +256,13 @@ class KodexaPlatform:
         Returns: The access token if it is defined in the user config store, or as an environment variable
 
         """
-        kodexa_config = get_config()
+        kodexa_config = get_config(profile)
         access_token = os.getenv('KODEXA_ACCESS_TOKEN')
-        return access_token if access_token is not None else kodexa_config['access_token']
+        return access_token if access_token is not None else \
+            kodexa_config[profile]['access_token'] if profile else kodexa_config['access_token']
 
     @staticmethod
-    def get_url() -> str:
+    def get_url(profile=None) -> str:
         """
         Returns the URL to use to access a Kodexa Platform
 
@@ -269,9 +273,9 @@ class KodexaPlatform:
         Returns: The URL if it is defined in the user config store, or as an environment variable
 
         """
-        kodexa_config = get_config()
+        kodexa_config = get_config(profile)
         env_url = os.getenv('KODEXA_URL', None)
-        return env_url if env_url is not None else kodexa_config['url']
+        return env_url if env_url is not None else kodexa_config[profile]['url'] if profile else kodexa_config['url']
 
     @staticmethod
     def set_access_token(access_token: str):
@@ -336,15 +340,19 @@ class KodexaPlatform:
         return [org_slug, slug, version]
 
     @classmethod
-    def login(cls, kodexa_url, username, password):
+    def login(cls, kodexa_url, username, password, profile=None):
         from requests.auth import HTTPBasicAuth
         obj_response = requests.get(f"{kodexa_url}/api/account/me/token",
                                     auth=HTTPBasicAuth(username, password),
                                     headers={"content-type": "application/json"})
         if obj_response.status_code == 200:
-            kodexa_config = get_config()
-            kodexa_config['url'] = kodexa_url
-            kodexa_config['access_token'] = obj_response.text
+            kodexa_config = get_config(profile)
+            if profile and profile in kodexa_config:
+                kodexa_config[profile]['url'] = kodexa_url
+                kodexa_config[profile]['access_token'] = obj_response.text
+            else:
+                kodexa_config['url'] = kodexa_url
+                kodexa_config['access_token'] = obj_response.text
             save_config(kodexa_config)
             print("Logged in")
         else:

{kodexa-6.1.2a4891138870 → kodexa-6.1.2a5059971029}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "kodexa"
-version = "6.1.2a4891138870"
+version = "6.1.2a5059971029"
 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.1.2a4891138870 → kodexa-6.1.2a5059971029}/setup.py

@@ -37,7 +37,7 @@ install_requires = \
 
 setup_kwargs = {
     'name': 'kodexa',
-    'version': '6.1.2a4891138870',
+    'version': '6.1.2a5059971029',
     '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\n[//]: # (Replace it with the diagrams and descriptions for build releases)\n**BUILD VERSION FLOW**\n![build-version-flow.png](docs%2Fbuild-version-flow.png)\nBuild version will differ based on the branches that are published to pypi.\n\n**GITHUB PROCESS**\n![github-process.png](docs%2Fgithub-process.png)\nChanges that contain bugs, features, and fixes should first be pushed to the test branch. \nOnce these changes are thoroughly tested, they can be submitted as a pull request to the main branch. The pull request should be reviewed and approved by an appropriate person before the changes can be merged.\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\n',
     'author': 'Austin Redenbaugh',