kodexa 6.1.2b4615788456__py3-none-any.whl → 6.1.2b5059981385__py3-none-any.whl

kodexa/assistant/assistant.py

@@ -7,6 +7,115 @@ from typing import List, Optional
 from kodexa.model import ContentObject, Document
 from kodexa.model.objects import Store, Taxonomy, BaseEvent
 from kodexa.platform.client import DocumentStoreEndpoint
+import logging
+from kodexa.pipeline import Pipeline
+
+logger = logging.getLogger()
+
+
+def replace_option(option_type, option_value, event_helper, cache, kodexa_client):
+    logger.info("Replacing option")
+    if option_type == 'document':
+        # We need to download the document from the store and replace the option with it
+
+        full_url = option_value
+        logger.info(f"Breaking down the full url for the document {full_url}")
+
+        if '/' in full_url:
+            url_parts = full_url.split(':')
+
+            # Each part, split by "/"
+            version = url_parts[1].split("/")[0]
+            store_ref = f"{url_parts[0]}:{version}"
+            document_family_id = url_parts[1].split("/")[1]
+            logger.info(f"Downloading document parameter {store_ref}/{document_family_id}")
+
+            if store_ref != "" and document_family_id != "undefined":
+                try:
+
+                    logger.info(f"Using store {store_ref}")
+                    cache_key = f'store-{store_ref}'
+
+                    if cache_key not in cache:
+                        logger.info(f"Using store {store_ref}")
+                        from kodexa.platform.client import DocumentStoreEndpoint
+                        store: DocumentStoreEndpoint = kodexa_client.get_object_by_ref('store', store_ref)
+                        from kodexa.platform.client import DocumentFamilyEndpoint
+                        document_family: DocumentFamilyEndpoint = store.get_family(document_family_id)
+                        document = document_family.get_document()
+                        document.ref = full_url
+                        cache[cache_key] = document
+                        logger.info(f"Downloaded document")
+
+                    # We keep the ref of the document so we can use it later
+                    return cache[cache_key]
+
+                except Exception as e:
+                    logger.warning(f"Unable to access the document ({e})")
+                    return None
+            else:
+                logger.info(f"Document reference not available")
+                return None
+
+        elif len(full_url) > 0:
+            # We have an ID to a Content Object
+            return Document.from_kddb(event_helper.get_content_object(content_object_id=full_url).read())
+
+    if 'store' in option_type.lower():
+        logger.info(f"Getting Store object instance {option_type} as {option_value}")
+
+        # We need to create a remote store
+        store = kodexa_client.get_object_by_ref('store', option_value)
+        return store
+
+    if 'pipeline' in option_type.lower():
+        logger.info(f"Getting pipeline instance {option_type} as {option_value}")
+
+        # To create a pipeline to represent the option
+        pipeline = Pipeline()
+        pipeline.steps = []
+
+        if isinstance(option_value['steps'], list):
+
+            for index, step in enumerate(option_value['steps']):
+                logger.info(f"Creating step {step}")
+                pipeline.add_step(step['ref'], name=f'Step {index}', step_type=step['stepType'],
+                                  options=step['options'] if 'options' in step else {})
+
+        return pipeline
+
+    if option_type == 'taxonomy':
+        logger.info(f"Getting Taxonomy object instance {option_type} as {option_value}")
+
+        try:
+            taxonomy = kodexa_client.get_object_by_ref('taxo', option_value)
+        except Exception as e:
+            logger.warning(f"Unable to access the taxonomy ({e})")
+            return None
+        return taxonomy
+
+    logger.info("Returning option value")
+    return option_value
+
+
+def replace_options(step, event_helper, cache, kodexa_client):
+    logger.info(f"Determine is we have any options that need replacement")
+    # We need to document any documents that are part of the options
+    for key in step.option_types.keys():
+        logger.info(f"Check option type for key {key}")
+
+        if key in step.options:
+            logger.info(f"Type is {step.option_types[key]}")
+            if step.option_types[key].startswith('list:'):
+                result = []
+                logger.info("Is a list type")
+                for value in step.options[key]:
+                    result.append(
+                        replace_option(step.option_types[key].split(':')[1], value, event_helper, cache, kodexa_client))
+                step.options[key] = result
+            else:
+                step.options[key] = replace_option(step.option_types[key], step.options[key], event_helper,
+                                                   cache, kodexa_client)
 
 
 class AssistantMetadata:
@@ -201,4 +310,4 @@ class Assistant:
         Returns:
           AssistantResponse: the response to the event
 
-        """
+        """

kodexa/model/model.py

@@ -14,7 +14,8 @@ import msgpack
 from addict import Dict
 
 from kodexa.model.base import KodexaBaseModel
-from kodexa.model.objects import ContentObject
+from kodexa.model.objects import ContentObject, FeatureSet
+import deepdiff
 
 
 class Ref:
@@ -50,7 +51,8 @@ class ContentException(Dict):
 
     def __init__(self, exception_type: str, message: str, severity: str = 'ERROR', tag: Optional[str] = None,
                  group_uuid: Optional[str] = None, tag_uuid: Optional[str] = None,
-                 exception_details: Optional[str] = None, node_uuid: Optional[str] = None, *args, **kwargs):
+                 exception_details: Optional[str] = None, node_uuid: Optional[str] = None, value: Optional[str] = None,
+                 *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.tag = tag
         self.message = message
@@ -60,6 +62,7 @@ class ContentException(Dict):
         self.exception_type = exception_type
         self.node_uuid = node_uuid
         self.severity = severity
+        self.value = value
 
 
 class Tag(Dict):
@@ -79,7 +82,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"""
@@ -1535,10 +1538,17 @@ 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]
-                    if potential_next_node:
-                        return potential_next_node
+                    try:
+                        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
+                    except:
+                        # traverse additional layer
+                        potential_next_node = self.get_parent().get_parent().get_parent().get_children()[
+                            self.get_parent().get_parent().index + 1].get_children()[0].get_children()[0]
+                        if potential_next_node:
+                            return potential_next_node
                 return node
 
             if compiled_node_type_re.match(node.node_type) and (not skip_virtual or not node.virtual):
@@ -1702,6 +1712,132 @@ class ContentClassification(object):
                                      selector=dict_val.get('selector'), confidence=dict_val.get('confidence'))
 
 
+class FeatureSetDiff:
+    """
+    A utility class that can be used to diff two feature sets
+    """
+
+    def __init__(self, first_feature_set: FeatureSet, second_feature_set: FeatureSet):
+        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 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}
+
+    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):
     """A Document is a collection of metadata and a set of content nodes."""
 
@@ -1757,6 +1893,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 +1904,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
 
@@ -2273,6 +2442,49 @@ class Document(object):
         """
         return self.labels
 
+    def get_feature_set(self) -> FeatureSet:
+        """
+        Build a feature set of all the tagged nodes
+
+        :return:
+        """
+        feature_set = FeatureSet()
+        feature_set.node_features = []
+        for tagged_node in self.get_all_tagged_nodes():
+            node_feature = {
+                'nodeUuid': str(tagged_node.uuid),
+                'features': []
+            }
+
+            feature_set.node_features.append(node_feature)
+
+            # TODO this needs to be cleaned up
+            for feature in tagged_node.get_features():
+                if feature.feature_type == 'tag':
+                    feature_dict = feature.to_dict()
+                    feature_dict['featureType'] = feature.feature_type
+                    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
+
+        :return:
+        """
+        return self._persistence_layer.get_all_tagged_nodes()
+
+
+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/model/objects.py

@@ -1350,6 +1350,7 @@ class Option(KodexaBaseModel):
     support_article: Optional[str] = Field(None, alias='supportArticle')
     overview_markdown: Optional[str] = Field(None, alias='overviewMarkdown')
     show_if: Optional[str] = Field(None, alias='showIf')
+    show_on_popup: Optional[bool] = Field(None, alias='showOnPopup')
     possible_values: Optional[List[PossibleValue]] = Field(None, alias='possibleValues')
     properties: Optional[Dict[str, Any]] = None
 

kodexa/model/persistence.py

@@ -581,6 +581,16 @@ class SqliteDocumentPersistence(object):
     def clear_model_insights(self):
         self.cursor.execute("delete from model_insights")
 
+    def get_all_tagged_nodes(self):
+        content_nodes = []
+        query = f"select cn_id from ft where f_type in (select id from f_type where name like 'tag:%')"
+        for content_node_ids in self.cursor.execute(
+                query).fetchall():
+            content_nodes.append(self.get_node(content_node_ids[0]))
+
+        return content_nodes
+
+
 
 class SimpleObjectCache(object):
     """
@@ -669,6 +679,10 @@ class PersistenceManager(object):
         self.flush_cache()
         return self._underlying_persistence.get_tagged_nodes(tag, tag_uuid)
 
+    def get_all_tagged_nodes(self):
+        self.flush_cache()
+        return self._underlying_persistence.get_all_tagged_nodes()
+
     def initialize(self):
         self._underlying_persistence.initialize()
 

kodexa/platform/client.py

@@ -192,6 +192,28 @@ class ProjectResourceEndpoint(ClientEndpoint):
             df.drop(columns='client', axis=1)
         return df
 
+    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/projects/{self.project.id}/{self.get_type()}"
@@ -389,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()}"
 
@@ -1605,7 +1648,7 @@ class DocumentFamilyEndpoint(DocumentFamily, ClientEndpoint):
                 self.client)
             if mixin and mixin in updated_document_family.mixins:
                 return updated_document_family
-            if label and label in updated_document_family.labels:
+            if label and any(l.name == label for l in updated_document_family.labels):
                 return updated_document_family
 
             time.sleep(5)
@@ -1677,28 +1720,10 @@ class DocumentFamilyEndpoint(DocumentFamily, ClientEndpoint):
 
     def replace_tags(self, document: Document, content_object: Optional[ContentObject] = None):
         """Replace the tags of the document family"""
-        feature_set = FeatureSet()
         if content_object is None:
             content_object = self.content_objects[-1]
-        feature_set.node_features = []
-        for tagged_node in document.select('//*[hasTag()]'):
-            node_feature = {
-                'nodeUuid': str(tagged_node.uuid),
-                'features': []
-            }
-
-            feature_set.node_features.append(node_feature)
-
-            # TODO this needs to be cleaned up
-            for feature in tagged_node.get_features():
-                if feature.feature_type == 'tag':
-                    feature_dict = feature.to_dict()
-                    feature_dict['featureType'] = feature.feature_type
-                    feature_dict['name'] = feature.name
-                    node_feature['features'].append(feature_dict)
-
         url = f"/api/stores/{self.store_ref.replace(':', '/')}/families/{self.id}/objects/{content_object.id}/_replaceTags"
-        self.client.put(url, body=feature_set.dict(by_alias=True))
+        self.client.put(url, body=document.get_feature_set().dict(by_alias=True))
 
 
 class StoreEndpoint(ComponentInstanceEndpoint, Store):
@@ -2166,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
@@ -2585,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)
@@ -2665,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)
@@ -2675,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.2b4615788456.dist-info → kodexa-6.1.2b5059981385.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kodexa
-Version: 6.1.2b4615788456
+Version: 6.1.2b5059981385
 Summary: Python SDK for the Kodexa Platform
 Author: Austin Redenbaugh
 Author-email: austin@kodexa.com
@@ -70,7 +70,15 @@ Documentation is available at the [Kodexa Documentation Portal](https://docs.kod
 
 ## Current Development
 
-The main branch is 6.0 which is a production release.
+[//]: # (Replace it with the diagrams and descriptions for build releases)
+**BUILD VERSION FLOW**
+![build-version-flow.png](docs%2Fbuild-version-flow.png)
+Build version will differ based on the branches that are published to pypi.
+
+**GITHUB PROCESS**
+![github-process.png](docs%2Fgithub-process.png)
+Changes that contain bugs, features, and fixes should first be pushed to the test branch. 
+Once 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.
 
 ## Set-up
 
@@ -90,3 +98,4 @@ We welcome contributions to the Kodexa platform. Please see our [contributing gu
 
 Apache 2.0
 
+

{kodexa-6.1.2b4615788456.dist-info → kodexa-6.1.2b5059981385.dist-info}/RECORD

@@ -1,18 +1,18 @@
 kodexa/__init__.py,sha256=fpYUxplMg8ucktmxv62x3jW-8TXUe4EgTa5vnS6vg78,847
 kodexa/assistant/__init__.py,sha256=nlXm_YnV_50hgn0TIT2Fkc2fQ-86OjmctY_j8My9nc4,171
-kodexa/assistant/assistant.py,sha256=CNzKLHc0F7InuXQJdVVh60iO3c4-97xhzylDyF__wUk,7952
+kodexa/assistant/assistant.py,sha256=LknWUtItHnMHlxXbw37Q5uUHelmSFGLSkTJ7q6LqEqc,12530
 kodexa/connectors/__init__.py,sha256=WCUEzFGjHcgPAMFIKLaRTXAkGHx3vUCD8APMhOrNNgM,297
 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=IKtqT5lEDPYQlcuAX8Yy8meb66Sy_1tyMoiKgoqQqvI,88616
-kodexa/model/objects.py,sha256=afckMl6Mjc-C-Jvl1sly8sckrujWvV4bOpi3e9ruUlc,116415
-kodexa/model/persistence.py,sha256=_d-FEAclxllSTMLqdlQ2-DbGoYaLkAMpB6fPj9xuYZQ,37847
+kodexa/model/model.py,sha256=_fV5srWiX_iBQfdtlI7YjyGLJDTBuktysuF8VlO8Sv0,96183
+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=EK_ZnOJK6AGYbxYfKZfXiNbaV-Vo54oZ8QrIeqYsd7s,109544
-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.2b4615788456.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-kodexa-6.1.2b4615788456.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-kodexa-6.1.2b4615788456.dist-info/METADATA,sha256=cQtTw-hcJwHP_4aLE8dUYKxpAy3D3wZgSdBP964gvNY,3611
-kodexa-6.1.2b4615788456.dist-info/RECORD,,
+kodexa-6.1.2b5059981385.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+kodexa-6.1.2b5059981385.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+kodexa-6.1.2b5059981385.dist-info/METADATA,sha256=mmaA2EaUdk2p2viA0kczg9LJQ98vTrCS4vTcOEPezB0,4159
+kodexa-6.1.2b5059981385.dist-info/RECORD,,