kodexa 7.0.1a8003211616__py3-none-any.whl → 7.0.1a9194120328__py3-none-any.whl

kodexa/platform/client.py

@@ -85,7 +85,7 @@ from kodexa.model.objects import (
     ReprocessRequest,
     PageExtensionPack,
     PageOrganization,
-    DocumentFamilyStatistics, MessageContext, PagePrompt, Prompt, GuidanceSet, PageGuidanceSet,
+    DocumentFamilyStatistics, MessageContext, PagePrompt, Prompt, GuidanceSet, PageGuidanceSet, DocumentEmbedding,
 )
 
 logger = logging.getLogger()
@@ -491,9 +491,9 @@ class ComponentEndpoint(ClientEndpoint, OrganizationOwned):
             # Yield each endpoint in the current page
             for endpoint in (
                     self.get_page_class(list_response.json())
-                        .model_validate(list_response.json())
-                        .set_client(self.client)
-                        .to_endpoints()
+                            .model_validate(list_response.json())
+                            .set_client(self.client)
+                            .to_endpoints()
             ):
                 yield endpoint
 
@@ -548,7 +548,7 @@ class ComponentEndpoint(ClientEndpoint, OrganizationOwned):
         Returns:
             The created component.
         """
-        url = f"/api/{self.get_type()}/{self.organization.slug}/"
+        url = f"/api/{self.get_type()}/{self.organization.slug}"
         get_response = self.client.post(
             url, component.model_dump(mode="json", by_alias=True)
         )
@@ -774,7 +774,7 @@ class EntitiesEndpoint:
         Returns:
             PageProject: The page of projects belonging to the organization.
         """
-        url = f"/api/{self.get_type()}/"
+        url = f"/api/{self.get_type()}"
         get_response = self.client.get(
             url, params={"filter": f"organization.id: '{organization.id}'"}
         )
@@ -1598,6 +1598,83 @@ class OrganizationEndpoint(Organization, EntityEndpoint):
         """
         return TaxonomiesEndpoint().set_client(self.client).set_organization(self)
 
+    @property
+    def available_templates(self, page=1, page_size=10, query="*"):
+        """
+        Get the available templates for the organization.
+
+        Returns:
+            MarketplaceEndpoint: The marketplace endpoint of the organization.
+        """
+        url = f"/api/organizations/{self.id}/availableTemplates"
+        response = self.client.get(url, params={"page": page, "pageSize": page_size, "query": query})
+        return PageProjectTemplateEndpoint.model_validate(response.json()).set_client(self.client)
+
+    @property
+    def available_models(self, page=1, page_size=10, query="*"):
+        """
+        Get the available models for the organization.
+
+        Returns:
+            MarketplaceEndpoint: The marketplace endpoint of the organization.
+        """
+        url = f"/api/organizations/{self.id}/availableModels"
+        response = self.client.get(url, params={"page": page, "pageSize": page_size, "query": query})
+        return PageStoreEndpoint.model_validate(response.json()).set_client(self.client)
+
+    @property
+    def available_assistants(self, page=1, page_size=10, query="*"):
+        """
+        Get the available assistants for the organization.
+
+        Returns:
+            MarketplaceEndpoint: The marketplace endpoint of the organization.
+        """
+        url = f"/api/organizations/{self.id}/availableAssistants"
+        response = self.client.get(url, params={"page": page, "pageSize": page_size, "query": query})
+        return PageAssistantDefinitionEndpoint.model_validate(response.json()).set_client(self.client)
+
+    def get_subscriptions(self, page: int = 1, page_size: int = 10) -> "PageProductSubscriptionEndpoint":
+        """
+        Get the subscriptions of the organization.
+
+        Returns:
+            The subscriptions of the organization.
+        """
+        url = f"/api/productSubscriptions"
+        params = {
+            "filter": f"organization.id: '{self.id}'",
+            "page": page,
+            "pageSize": page_size
+        }
+        response = self.client.get(url, params=params)
+
+        from kodexa.model.entities.product_subscription import PageProductSubscriptionEndpoint
+        return PageProductSubscriptionEndpoint.model_validate(response.json()).set_client(self.client)
+
+    def remove_subscription(self, subscription: "ProductSubscription") -> None:
+        """
+        Remove a subscription from the organization.
+
+        Args:
+            subscription_id (str): The id of the subscription to remove.
+        """
+        url = f"/api/productSubscriptions/{subscription.id}"
+        self.client.delete(url)
+
+    def add_subscription(self, product: "Product") -> None:
+        """
+        Add a subscription to the organization.
+
+        Args:
+            product (Product): The product to subscribe to.
+        """
+        url = f"/api/productSubscriptions"
+        from kodexa.model.entities.product_subscription import ProductSubscription
+        new_product_subscription = ProductSubscription(organization=self.detach(), product=product)
+        print(new_product_subscription.model_dump_json(by_alias=True))
+        self.client.post(url, body=json.loads(new_product_subscription.model_dump_json(by_alias=True)))
+
 
 class ComponentsEndpoint(ClientEndpoint):
     """
@@ -1725,13 +1802,15 @@ class ComponentInstanceEndpoint(ClientEndpoint, SlugBasedMetadata):
             raise Exception(f"Component {self.ref} already exists")
 
         if exists:
-            self.client.put(url, self.model_dump(mode="json", by_alias=True))
+            response = self.client.put(url, self.model_dump(mode="json", by_alias=True))
+            process_response(response)
             return self.post_deploy()
 
-        self.client.post(
+        response = self.client.post(
             f"/api/{self.get_type()}/{self.org_slug}",
             self.model_dump(mode="json", by_alias=True),
         )
+        process_response(response)
         return self.post_deploy()
 
 
@@ -2072,6 +2151,33 @@ class ProjectTaxonomiesEndpoint(ProjectResourceEndpoint):
         return TaxonomyEndpoint
 
 
+class ProjectGuidanceEndpoint(ProjectResourceEndpoint):
+
+    def get_type(self) -> str:
+        return "guidance"
+
+    def get_instance_class(self, object_dict=None):
+        return GuidanceSetEndpoint
+
+
+class ProjectDataFormEndpoint(ProjectResourceEndpoint):
+
+    def get_type(self) -> str:
+        return "dataForms"
+
+    def get_instance_class(self, object_dict=None):
+        return DataFormEndpoint
+
+
+class ProjectDashboardEndpoint(ProjectResourceEndpoint):
+
+    def get_type(self) -> str:
+        return "dashboards"
+
+    def get_instance_class(self, object_dict=None):
+        return DashboardEndpoint
+
+
 class ProjectStoresEndpoint(ProjectResourceEndpoint):
     """Represents a project stores endpoint"""
 
@@ -2352,20 +2458,25 @@ class ProjectEndpoint(EntityEndpoint, Project):
             self,
             stores: List["StoreEndpoint"] = None,
             taxonomies: List["TaxonomyEndpoint"] = None,
-    ) -> "ProjectEndpoint":
+            data_forms: List["DataFormEndpoint"] = None,
+            guidance: List["GuidanceSetEndpoint"] = None,
+            dashboards: List["DashboardEndpoint"] = None,
+    ):
         """Update the resources of the project.
 
         Args:
             stores (List["StoreEndpoint"], optional): List of store endpoints to update.
             taxonomies (List["TaxonomyEndpoint"], optional): List of taxonomy endpoints to update.
-
-        Returns:
-            ProjectEndpoint: The updated project endpoint.
+            data_forms (List["DataFormEndpoint"], optional): List of data form endpoints to update.
+            guidance (List["GuidanceSetEndpoint"], optional): List of guidance set endpoints to update.
+            dashboards (List["DashboardEndpoint"], optional): List of dashboard endpoints to update.
         """
         project_resources_update = ProjectResourcesUpdate()
         project_resources_update.store_refs = []
         project_resources_update.taxonomy_refs = []
         project_resources_update.dashboard_refs = []
+        project_resources_update.data_form_refs = []
+        project_resources_update.guidance_set_refs = []
 
         if stores:
             project_resources_update.store_refs = [store.ref for store in stores]
@@ -2374,6 +2485,18 @@ class ProjectEndpoint(EntityEndpoint, Project):
             project_resources_update.taxonomy_refs = [
                 taxonomy.ref for taxonomy in taxonomies
             ]
+        if data_forms:
+            project_resources_update.data_form_refs = [
+                data_form.ref for data_form in data_forms
+            ]
+        if guidance:
+            project_resources_update.guidance_set_refs = [
+                guidance.ref for guidance in guidance
+            ]
+        if dashboards:
+            project_resources_update.dashboard_refs = [
+                dashboard.ref for dashboard in dashboards
+            ]
 
         self.client.put(
             f"/api/projects/{self.id}/resources",
@@ -2416,6 +2539,15 @@ class ProjectEndpoint(EntityEndpoint, Project):
         """
         return ProjectTaxonomiesEndpoint().set_client(self.client).set_project(self)
 
+    @property
+    def guidance(self) -> "ProjectGuidanceEndpoint":
+        """Get the guidance sets endpoint of the project.
+
+        Returns:
+            GuidanceSetsEndpoint: The guidance sets endpoint of the project.
+        """
+        return ProjectGuidanceEndpoint().set_client(self.client).set_project(self)
+
     @property
     def assistants(self) -> ProjectAssistantsEndpoint:
         """Get the assistants endpoint of the project.
@@ -2450,6 +2582,43 @@ class ProjectEndpoint(EntityEndpoint, Project):
         return [ProjectTag.model_validate(tag) for tag in response.json()]
 
 
+class GuidanceSetsEndpoint(EntitiesEndpoint):
+    """Represents a message endpoint"""
+
+    def get_type(self) -> str:
+        """
+        Get the type of the endpoint.
+
+        Returns:
+            str: The type of the endpoint, in this case "guidance".
+        """
+        return "guidance"
+
+    def get_instance_class(self, object_dict=None):
+        """
+        Get the instance class of the endpoint.
+
+        Args:
+            object_dict (dict, optional): An optional dictionary object. Defaults to None.
+
+        Returns:
+            GuidanceSetEndpoint: The instance class of the endpoint.
+        """
+        return GuidanceSetEndpoint
+
+    def get_page_class(self, object_dict=None):
+        """
+        Get the page class of the endpoint.
+
+        Args:
+            object_dict (dict, optional): An optional dictionary object. Defaults to None.
+
+        Returns:
+            PageGuidanceSetEndpoint: The page class of the endpoint.
+        """
+        return PageGuidanceSetEndpoint
+
+
 class MessagesEndpoint(EntitiesEndpoint):
     """Represents a message endpoint"""
 
@@ -2652,12 +2821,13 @@ class ProjectsEndpoint(EntitiesEndpoint):
         """
         return PageProjectEndpoint
 
-    def find_by_name(self, project_name: str) -> Optional[ProjectEndpoint]:
+    def find_by_name(self, project_name: str, organization: Optional[Organization] = None) -> Optional[ProjectEndpoint]:
         """
         Find a project by name.
 
         Args:
             project_name (str): The name of the project to find.
+            organization (Organization, optional): The organization to search in. Defaults to None.
 
         Returns:
             Optional[ProjectEndpoint]: The project endpoint if found, None otherwise.
@@ -2665,8 +2835,8 @@ class ProjectsEndpoint(EntitiesEndpoint):
 
         url = f"/api/{self.get_type()}"
         filters = {"filter": [f"name: '{project_name}'"]}
-        if self.organization is not None:
-            filters["filter"].append(f"organization.id: '{self.organization.id}'")
+        if organization is not None:
+            filters["filter"].append(f"organization.id: '{organization.id}'")
         get_response = self.client.get(url, params=filters)
         if len(get_response.json()["content"]) > 0:
             return ProjectEndpoint.model_validate(
@@ -2734,7 +2904,7 @@ class ProjectsEndpoint(EntitiesEndpoint):
         if self.organization is not None:
             params["filter"].append(f"organization.id: '{self.organization.id}'")
 
-        get_response = self.client.get(f"/api/{self.get_type()}/", params=params)
+        get_response = self.client.get(f"/api/{self.get_type()}", params=params)
 
         return PageProjectEndpoint.model_validate(get_response.json()).set_client(
             self.client
@@ -2837,16 +3007,17 @@ class GuidanceEndpoint(ComponentEndpoint, ClientEndpoint, OrganizationOwned):
     """
     Represents a guidance endpoint.
 
-    This class is used to interact with the prompts endpoint of the API.
+    This class is used to interact with the guidance endpoint of the API.
     It provides methods to get the type, page class, and instance class of the endpoint,
     as well as to deploy an extension pack from a URL.
     """
+
     def get_type(self) -> str:
         """
         Get the type of the endpoint.
 
         Returns:
-            str: The type of the endpoint, "prompts".
+            str: The type of the endpoint, "guidance".
         """
         return "guidance"
 
@@ -2883,6 +3054,7 @@ class PromptsEndpoint(ComponentEndpoint, ClientEndpoint, OrganizationOwned):
     It provides methods to get the type, page class, and instance class of the endpoint,
     as well as to deploy an extension pack from a URL.
     """
+
     def get_type(self) -> str:
         """
         Get the type of the endpoint.
@@ -4973,10 +5145,28 @@ class DataStoreEndpoint(StoreEndpoint):
 
 
 class DocumentStoreEndpoint(StoreEndpoint):
-    """Represents a document store that can be used to store files and their related document representations."""
-
     """Represents a document store that can be used to store files and then their related document representations"""
 
+    def query_by_embedding(self, embedding: list[float], threshold: float, limit: int):
+        """
+        Query the document store by an embedding.
+
+        Args:
+            embedding (list[float]): The embedding to query by.
+            threshold (int): The threshold to use for the query.
+            limit (int): The limit of the query.
+
+        Returns:
+            list[DocumentEmbedding]: a list of document embeddings
+        """
+        url = "/api/embeddings/query"
+        embedding_query = {"embedding": embedding, "threshold": threshold, "limit": limit, "storeRef": self.ref}
+        response = self.client.post(url, body=embedding_query)
+        process_response(response)
+
+        # We get a list of the document embeddings
+        return [DocumentEmbedding.model_validate(embedding) for embedding in response.json()]
+
     def delete_by_path(self, object_path: str):
         """
         Delete the content stored in the store at the given path.
@@ -5271,6 +5461,8 @@ class DocumentStoreEndpoint(StoreEndpoint):
                 count += 1
                 if limit and count >= limit:
                     break
+            if limit and count >= limit:
+                break
             page += 1
 
     def filter(
@@ -5357,6 +5549,7 @@ class DocumentStoreEndpoint(StoreEndpoint):
             f"api/stores/{self.ref.replace(':', '/')}/fs",
             params={"path": path, "meta": True},
         )
+        process_response(get_response)
         return DocumentFamilyEndpoint.model_validate(get_response.json()).set_client(
             self.client
         )
@@ -5448,6 +5641,7 @@ class ModelStoreEndpoint(DocumentStoreEndpoint):
         response = self.client.get(
             f"/api/stores/{self.ref.replace(':', '/')}/trainings/{training_id}/content"
         )
+        process_response(response)
         from zipfile import ZipFile
         from io import BytesIO
 
@@ -5467,6 +5661,7 @@ class ModelStoreEndpoint(DocumentStoreEndpoint):
         response = self.client.get(
             f"/api/stores/{self.ref.replace(':', '/')}/implementation"
         )
+        process_response(response)
         from zipfile import ZipFile
         from io import BytesIO
 
@@ -5652,6 +5847,11 @@ class ModelStoreEndpoint(DocumentStoreEndpoint):
                         zipf.write(path_hit, relative_path)
                         num_hits += 1
 
+        if num_hits == 0:
+            print(
+                f"No files found for implementation in {metadata.base_dir} with {metadata.contents}"
+            )
+
         return num_hits
 
     def upload_contents(self, metadata: ModelContentMetadata, dry_run=False):
@@ -5669,10 +5869,11 @@ class ModelStoreEndpoint(DocumentStoreEndpoint):
             num_hits = self.build_implementation_zip(metadata)
             if num_hits > 0 and not dry_run:
                 with open("implementation.zip", "rb") as zip_content:
-                    self.client.post(
+                    response = self.client.post(
                         f"/api/stores/{self.ref.replace(':', '/')}/implementation",
                         files={"implementation": zip_content},
                     )
+                    process_response(response)
                 results.append(f"{num_hits} files packaged and deployed to {self.ref}")
         if not metadata.keep_zip:
             Path("implementation.zip").unlink()
@@ -5754,6 +5955,8 @@ def process_response(response) -> requests.Response:
         raise Exception(f"Unauthorized ({response.text})")
     if response.status_code == 404:
         raise Exception(f"Not found ({response.text})")
+    if response.status_code in [301, 302]:
+        raise Exception(f"Redirected ({response.text})")
     if response.status_code == 405:
         raise Exception("Method not allowed")
     if response.status_code == 500:
@@ -5769,11 +5972,6 @@ def process_response(response) -> requests.Response:
 
     return response
 
-    #
-    #  The Kodexa Client is the way that brings everything together
-    #
-    #
-
 
 OBJECT_TYPES = {
     "extensionPacks": {
@@ -5969,9 +6167,10 @@ class ExtractionEngineEndpoint:
         """
         response = self.client.post(
             "/api/extractionEngine/extract",
-            data={"taxonomyJson": taxonomy.model_dump_json()},
+            data={"taxonomyJson": taxonomy.model_dump_json(by_alias=True)},
             files={"document": document.to_kddb()},
         )
+        print(response.json())
         return [
             DataObject.model_validate(data_object) for data_object in response.json()
         ]
@@ -5992,7 +6191,7 @@ class ExtractionEngineEndpoint:
         response = self.client.post(
             "/api/extractionEngine/extract",
             params="full",
-            data={"taxonomyJson": taxonomy.model_dump_json()},
+            data={"taxonomyJson": taxonomy.model_dump_json(by_alias=True)},
             files={"document": document.to_kddb()},
         )
         return {
@@ -6023,7 +6222,7 @@ class ExtractionEngineEndpoint:
         response = self.client.post(
             "/api/extractionEngine/extract",
             params={"format": format},
-            data={"taxonomyJson": taxonomy.model_dump_json()},
+            data={"taxonomyJson": taxonomy.model_dump_json(by_alias=True)},
             files={"document": document.to_kddb()},
         )
         return response.text
@@ -6046,7 +6245,7 @@ class KodexaClient:
         messages (MessagesEndpoint): An endpoint for messages.
     """
 
-    def __init__(self, url=None, access_token=None, profile="default"):
+    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(profile)
@@ -6064,16 +6263,18 @@ class KodexaClient:
         self.channels = ChannelsEndpoint(self)
         self.assistants = AssistantsEndpoint(self)
         self.messages = MessagesEndpoint(self)
+        from kodexa.model.entities.product import ProductsEndpoint
+        self.products = ProductsEndpoint(self)
+        self.guidance_sets = GuidanceSetsEndpoint(self)
 
     @staticmethod
-    def login(url, email, password):
+    def login(url, token):
         """
         A static method to login to the Kodexa platform.
 
         Args:
             url (str): The URL for the Kodexa platform.
-            email (str): The email for the user.
-            password (str): The password for the user.
+            token (str): The email for the user.
 
         Returns:
             KodexaClient: A KodexaClient instance.
@@ -6084,9 +6285,10 @@ class KodexaClient:
         from requests.auth import HTTPBasicAuth
 
         obj_response = requests.get(
-            f"{url}/api/account/me/token",
-            auth=HTTPBasicAuth(email, password),
-            headers={"content-type": "application/json"}
+            f"{url}/api/account/me",
+            headers={"content-type": "application/json",
+                     "x-access-token": token,
+                     "cf-access-token": os.environ.get("CF_TOKEN", "")}
         )
         if obj_response.status_code == 200:
             return KodexaClient(url, obj_response.text)
@@ -6218,6 +6420,7 @@ class KodexaClient:
             params=params,
             headers={
                 "x-access-token": self.access_token,
+                "cf-access-token": os.environ.get("CF_TOKEN", ""),
                 "content-type": "application/json",
             },
         )
@@ -6244,7 +6447,9 @@ class KodexaClient:
             params=params,
             headers={
                 "x-access-token": self.access_token,
+                "cf-access-token": os.environ.get("CF_TOKEN", ""),
                 "content-type": "application/json",
+                "X-Requested-With": "XMLHttpRequest",
             }
         )
 
@@ -6266,7 +6471,10 @@ class KodexaClient:
         Returns:
             requests.Response: The response from the server.
         """
-        headers = {"x-access-token": self.access_token}
+        headers = {
+            "x-access-token": self.access_token,
+            "X-Requested-With": "XMLHttpRequest",
+            "cf-access-token": os.environ.get("CF_TOKEN", "")}
         if files is None:
             headers["content-type"] = "application/json"
 
@@ -6296,7 +6504,9 @@ class KodexaClient:
         Returns:
             requests.Response: The response from the server.
         """
-        headers = {"x-access-token": self.access_token}
+        headers = {"x-access-token": self.access_token,
+                   "cf-access-token": os.environ.get("CF_TOKEN", ""),
+                   "X-Requested-With": "XMLHttpRequest"}
         if files is None:
             headers["content-type"] = "application/json"
 
@@ -6324,7 +6534,9 @@ class KodexaClient:
         response = requests.delete(
             self.get_url(url),
             params=params,
-            headers={"x-access-token": self.access_token}
+            headers={"x-access-token": self.access_token,
+                     "cf-access-token": os.environ.get("CF_TOKEN", ""),
+                     "X-Requested-With": "XMLHttpRequest"}
         )
         return process_response(response)
 
@@ -6440,6 +6652,18 @@ class KodexaClient:
                     )
                 )
 
+        for guidance in project.guidance.list():
+            guidance_file = os.path.join(
+                project_export_dir, f"guidance-{guidance.slug}-{guidance.version}.json"
+            )
+            with open(guidance_file, "w") as f:
+                f.write(
+                    json.dumps(
+                        guidance.model_dump(mode="json", by_alias=True), indent=4
+                    )
+                )
+
+
     def import_project(self, organization: OrganizationEndpoint, import_path: str):
         """
         A method to import a project.
@@ -6533,6 +6757,13 @@ class KodexaClient:
                 taxonomy.ref = None
                 taxonomies.append(organization.taxonomies.create(taxonomy))
 
+        for guidance_file in glob.glob(os.path.join(import_path, "guidance-*.json")):
+            with open(guidance_file, "r") as f:
+                guidance = GuidanceSetEndpoint.model_validate(json.load(f))
+                guidance.org_slug = None
+                guidance.ref = None
+                organization.guidance.create(guidance)
+
         import time
 
         time.sleep(4)
@@ -6603,6 +6834,8 @@ class KodexaClient:
 
                 raise Exception("A store must have a storeType")
 
+            from kodexa.model.entities.product import ProductEndpoint
+            from kodexa.model.entities.product_subscription import ProductSubscriptionEndpoint
             known_components = {
                 "taxonomy": TaxonomyEndpoint,
                 "pipeline": PipelineEndpoint,
@@ -6626,6 +6859,8 @@ class KodexaClient:
                 "prompt": PromptEndpoint,
                 "guidance": GuidanceSetEndpoint,
                 "channel": ChannelEndpoint,
+                "product": ProductEndpoint,
+                "productSubscription": ProductSubscriptionEndpoint,
             }
 
             if component_type in known_components: