kodexa 6.1.2a4891138870__py3-none-any.whl → 6.1.2a5059971029__py3-none-any.whl

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/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/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.dist-info → kodexa-6.1.2a5059971029.dist-info}/METADATA

@@ -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.dist-info → kodexa-6.1.2a5059971029.dist-info}/RECORD

@@ -5,14 +5,14 @@ kodexa/connectors/__init__.py,sha256=WCUEzFGjHcgPAMFIKLaRTXAkGHx3vUCD8APMhOrNNgM
 kodexa/connectors/connectors.py,sha256=25-TffyGDjxHyp9ITug0qgr1nhqMAekmV5NVvbPGs7o,7722
 kodexa/model/__init__.py,sha256=DyCgkJU7rOfd4SMvPRLaPdklCNlkqCRRWiVPwjYn2GE,720
 kodexa/model/base.py,sha256=6IraEK3RomjPgFpPYkxjuLUriF958AusgJO21Dcopeg,753
-kodexa/model/model.py,sha256=lw2PWk7hZ2mHOBwpVkQg65FDiCHzU4S3QGyo6JrA1DA,90463
+kodexa/model/model.py,sha256=fjfWjT2I93tFZVlDUky8ovqgjsF36y19ZMEunDG3DAY,94643
 kodexa/model/objects.py,sha256=bTj_COUUgvoergrNjFuYOK4fsMnZxZg7Ff4KN7KS3kg,116484
 kodexa/model/persistence.py,sha256=ZWESzXS-jkGbp-NlPuQzQFxmZeRup7uNJjrUkGaYIOk,38334
 kodexa/pipeline/__init__.py,sha256=sA7f5D6qkdMrpp2xTIeefnrUBI6xxEEWostvxfX_1Cs,236
 kodexa/pipeline/pipeline.py,sha256=uzxe7HuSW1CKDZOrnV_LRHj3SHhbs14lvmMGJ_DIVdw,19763
 kodexa/platform/__init__.py,sha256=1O3oiWMg292NPL_NacKDnK1T3_R6cMorrPRue_9e-O4,216
-kodexa/platform/client.py,sha256=zNpVWuFa6BjjF6xD-lubOglVvh1cyExDgGe6v7o6KbY,109471
-kodexa/platform/kodexa.py,sha256=HcwQh1NKkwSzkngKLp_kEsLW0N_JlzORszoknSDFLT0,27604
+kodexa/platform/client.py,sha256=LCCTb0TxRBDtv1_8g_jPtaJIiRyx4SfmG__WACh9RI0,110197
+kodexa/platform/kodexa.py,sha256=OZCdYK34ZnFAvktDdwewAerG7DHEJxau858qo116-vA,28246
 kodexa/selectors/__init__.py,sha256=xA9-4vpyaAZWPSk3bh2kvDLkdv6XEmm7PjFbpziiTIk,100
 kodexa/selectors/ast.py,sha256=mTAcX_pjDiDy99ELxbMMwAAkzezOqz5uCyui9qz7Q4A,13499
 kodexa/selectors/core.py,sha256=FxrKEQNqCRBSyC37ymt6kTvv4O-dj6SN71UGLocxWWA,3698
@@ -34,7 +34,7 @@ kodexa/testing/test_components.py,sha256=i_9M6-bfUBdR1uYAzZZzWiW0M1DGKzE5mkNuHq4
 kodexa/testing/test_utils.py,sha256=HXM3S5FDzarzS6R7jkOHps6d6Ox2UtNqymoK6VCw8Zg,13596
 kodexa/training/__init__.py,sha256=xs2L62YpRkIRfslQwtQZ5Yxjhm7sLzX2TrVX6EuBnZQ,52
 kodexa/training/train_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kodexa-6.1.2a4891138870.dist-info/METADATA,sha256=E2n9N_kogWRBpgDfec8OLIj71-0PP9Ca_ynphjAaVuM,4159
-kodexa-6.1.2a4891138870.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-kodexa-6.1.2a4891138870.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-kodexa-6.1.2a4891138870.dist-info/RECORD,,
+kodexa-6.1.2a5059971029.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+kodexa-6.1.2a5059971029.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+kodexa-6.1.2a5059971029.dist-info/METADATA,sha256=u66WiBXiJMc24O67L_dLSDs-fZ7maUrRaPMiJJnGvqI,4159
+kodexa-6.1.2a5059971029.dist-info/RECORD,,