contentgrid-application-client 0.0.1__tar.gz

contentgrid_application_client-0.0.1/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2024 Xenit Solutions
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

contentgrid_application_client-0.0.1/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: contentgrid-application-client
+Version: 0.0.1
+Summary: Python Client for interacting with ContentGrid Applications
+Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
+License: Copyright 2024 Xenit Solutions
+        
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+        
+            http://www.apache.org/licenses/LICENSE-2.0
+        
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: contentgrid-hal-client==0.0.1
+
+# ContentGrid Python Client
+
+This ContentGrid Client is a Python library designed to interact with ContentGrid API endpoints, specifically in the HAL response type. For ContentGrid Applications, it provides a convenient interface for performing various operations such as fetching profiles, creating entities, fetching related entities, handling content attributes, and more.
+
+## Features
+
+- **Profile Handling**: Fetch profiles to retrieve HAL-forms specification about available entities and their attributes.
+- **Entity Operations**: Create, fetch, update, and delete entities using a simple functions without needing to worry about headers and authentication.
+- **Content Handling**: Upload and download content on content-attributes of entities.
+- **Error Handling**: Provides basic error handling for network requests.
+- **Attribute validation**: Provides attribute type checks for creating and updating entities. Checks wether attributes have the correct type and if all required attributes are present.
+
+## Installation
+
+To install the ContentGrid API Client, you can use pip:
+
+```bash
+pip install contentgrid-application-client
+```
+
+## Usage
+
+### ContentGridApplicationClient
+```python
+from contentgrid-application-client import ContentGridApplicationClient
+
+# Initialize the client with service account
+client = ContentGridApplicationClient(
+    client_endpoint="https://b93ccecf-3466-44c0-995e-2620a8c66ac3.eu-west-1.contentgrid.cloud",
+    auth_uri="https://auth.eu-west-1.contentgrid.cloud/realms/cg-eade54da-3903-4554-aa5e-2982cd4126f1/protocol/openid-connect/token",
+    client_id="your_client_id",
+    client_secret="your_client_secret"
+)
+
+# Initialize the client with token
+client = ContentGridApplicationClient(
+    client_endpoint="https://b93ccecf-3466-44c0-995e-2620a8c66ac3.eu-west-1.contentgrid.cloud",
+    token="your_token"
+)
+
+# Fetch profile
+profile = client.get_profile()
+
+# Create entity
+attributes = {
+    "name": "Example Entity",
+    "description": "This is an example entity"
+}
+entity = client.create_entity("entity-name", attributes)
+```
+
+## Testing
+Installing requirements:
+```bash
+    pip install -r requirements.txt
+```
+
+Running tests: 
+
+```bash
+    python -m pytest
+```
+
+Running tests with coverage:
+
+```bash
+    coverage run -m pytest && coverage report -m
+```
+

contentgrid_application_client-0.0.1/README.md

@@ -0,0 +1,69 @@
+# ContentGrid Python Client
+
+This ContentGrid Client is a Python library designed to interact with ContentGrid API endpoints, specifically in the HAL response type. For ContentGrid Applications, it provides a convenient interface for performing various operations such as fetching profiles, creating entities, fetching related entities, handling content attributes, and more.
+
+## Features
+
+- **Profile Handling**: Fetch profiles to retrieve HAL-forms specification about available entities and their attributes.
+- **Entity Operations**: Create, fetch, update, and delete entities using a simple functions without needing to worry about headers and authentication.
+- **Content Handling**: Upload and download content on content-attributes of entities.
+- **Error Handling**: Provides basic error handling for network requests.
+- **Attribute validation**: Provides attribute type checks for creating and updating entities. Checks wether attributes have the correct type and if all required attributes are present.
+
+## Installation
+
+To install the ContentGrid API Client, you can use pip:
+
+```bash
+pip install contentgrid-application-client
+```
+
+## Usage
+
+### ContentGridApplicationClient
+```python
+from contentgrid-application-client import ContentGridApplicationClient
+
+# Initialize the client with service account
+client = ContentGridApplicationClient(
+    client_endpoint="https://b93ccecf-3466-44c0-995e-2620a8c66ac3.eu-west-1.contentgrid.cloud",
+    auth_uri="https://auth.eu-west-1.contentgrid.cloud/realms/cg-eade54da-3903-4554-aa5e-2982cd4126f1/protocol/openid-connect/token",
+    client_id="your_client_id",
+    client_secret="your_client_secret"
+)
+
+# Initialize the client with token
+client = ContentGridApplicationClient(
+    client_endpoint="https://b93ccecf-3466-44c0-995e-2620a8c66ac3.eu-west-1.contentgrid.cloud",
+    token="your_token"
+)
+
+# Fetch profile
+profile = client.get_profile()
+
+# Create entity
+attributes = {
+    "name": "Example Entity",
+    "description": "This is an example entity"
+}
+entity = client.create_entity("entity-name", attributes)
+```
+
+## Testing
+Installing requirements:
+```bash
+    pip install -r requirements.txt
+```
+
+Running tests: 
+
+```bash
+    python -m pytest
+```
+
+Running tests with coverage:
+
+```bash
+    coverage run -m pytest && coverage report -m
+```
+

contentgrid_application_client-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel", "setuptools_scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "contentgrid-application-client"
+dynamic = ["version", "dependencies"]
+description = "Python Client for interacting with ContentGrid Applications"
+readme = "README.md"
+authors = [{ name = "Ranec Belpaire", email = "ranec.belpaire@xenit.eu" }]
+license = { file = "LICENSE" }
+ 
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+]
+
+requires-python = ">=3.5"
+
+[tool.setuptools_scm]
+write_to = "_version.txt"                                                                                                                                                                                                  
+root = "../"                                                                                                                                                                                                                   

contentgrid_application_client-0.0.1/pytest.ini

@@ -0,0 +1,5 @@
+[pytest]
+log_cli = 1
+log_cli_level = INFO
+log_cli_format = %(asctime)s [%(levelname)s] %(message)s (%(filename)s:%(lineno)s)
+log_cli_date_format=%Y-%m-%d %H:%M:%S

contentgrid_application_client-0.0.1/requirements.txt

@@ -0,0 +1 @@
+-e ../contentgrid_hal_client

contentgrid_application_client-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

contentgrid_application_client-0.0.1/setup.py

@@ -0,0 +1,11 @@
+from setuptools import setup
+import setuptools_scm
+
+# Retrieve the version using setuptools_scm
+version = setuptools_scm.get_version(root="../")
+
+setup(
+    install_requires=[
+        f"contentgrid-hal-client=={version}",
+    ],
+)

contentgrid_application_client-0.0.1/src/contentgrid_application_client/__init__.py

@@ -0,0 +1 @@
+from .application import InteractiveApplicationResponse, EntityCollection, EntityObject, Profile, PageInfo, ContentGridApplicationClient, hal_form_type_check

contentgrid_application_client-0.0.1/src/contentgrid_application_client/application.py

@@ -0,0 +1,328 @@
+from typing import List, Optional, Self
+import requests
+import os
+import logging
+import mimetypes
+
+from contentgrid_hal_client.exceptions import BadRequest, IncorrectAttributeType, MissingRequiredAttribute, NotFound
+from contentgrid_hal_client.hal import CurieRegistry, HALFormsClient, HALLink, HALResponse, InteractiveHALResponse
+from datetime import datetime
+from email.header import decode_header
+
+logging.basicConfig(level=logging.DEBUG)
+
+hal_form_type_check = {
+    "text" : (lambda value : type(value) == str),
+    "datetime" : (lambda value : is_valid_date_format(value)),
+    "checkbox" : (lambda value : type(value) == bool),
+    "number" : (lambda value : type(value) == int or type(value) == float),
+    "url" : (lambda value : value.startswith("http://") or value.startswith("https://"))
+}
+
+def is_valid_date_format(date_string):
+    try:
+        datetime.strptime(date_string, "%Y-%m-%dT%H:%M:%S.%fZ")
+        return True
+    except ValueError:
+        return False
+
+hal_form_types = {
+    "text" : "string",
+    "datetime" : "date (e.g.:2024-03-20T16:48:59.904Z)",
+    "checkbox" : "boolean",
+    "number" : "int/float",
+    "url" : "url"
+}
+
+class InteractiveApplicationResponse(InteractiveHALResponse):
+    def __init__(self, data: dict, client: "ContentGridApplicationClient", curie_registry: CurieRegistry = None) -> None:
+        assert isinstance(client, ContentGridApplicationClient)
+        super().__init__(data, client, curie_registry)
+        self.client : ContentGridApplicationClient = client
+
+class EntityCollection(InteractiveApplicationResponse):
+    def __init__(self, data: dict, client: HALFormsClient, curie_registry: CurieRegistry = None) -> None:
+        super().__init__(data, client, curie_registry)
+        self.page_info: PageInfo = None
+        if "page" in data.keys():
+            self.page_info = PageInfo(
+                size=data["page"]["size"],
+                total_elements=data["page"]["totalElements"],
+                total_pages=data["page"]["totalPages"],
+                number=data["page"]["number"],
+            )
+    
+    def get_entities(self) -> Optional[List["EntityObject"]]:
+        return self.get_embedded_objects_by_key("item", infer_type=EntityObject)
+
+    def get_entity_profile_link(self) -> HALLink:
+        return self.get_link("profile")
+        
+    def create_entity(self, attributes : dict, attribute_validation=True) -> "EntityObject":
+        self.client._transform_hal_links_to_uris(attributes=attributes)
+        if attribute_validation:
+            entity_profile = self.client.follow_link(self.get_entity_profile_link())
+            self.client._validate_params(entity_profile.templates["create-form"], attributes=attributes)
+        response = self.client.post(self.get_self_link().uri, json=attributes, headers={"Content-Type" : "application/json"})
+        data = self.client._validate_json_response(response)
+        return EntityObject(data=data, client=self.client)
+    
+    def first(self):
+        if not self.has_link("first"):
+            raise Exception(f"Collection {self.get_self_link()} has no first page")
+        self.__init__(data=self.client.follow_link(self.get_link("first"), infer_type=EntityCollection).data, client=self.client, curie_registry=self.curie_registry)
+
+    def last(self):
+        if not self.has_link("last"):
+            raise Exception(f"Collection {self.get_self_link()} has no last page")
+        self.__init__(data=self.client.follow_link(self.get_link("last"), infer_type=EntityCollection).data, client=self.client, curie_registry=self.curie_registry)
+
+    def next(self):
+        if not self.has_link("next"):
+            raise Exception(f"Collection {self.get_self_link()} has no next page")
+        self.__init__(data=self.client.follow_link(self.get_link("next"), infer_type=EntityCollection).data, client=self.client, curie_registry=self.curie_registry)
+
+    def prev(self):
+        if not self.has_link("prev"):
+            raise Exception(f"Collection {self.get_self_link()} has no prev page")
+        self.__init__(data=self.client.follow_link(self.get_link("last"), infer_type=EntityCollection).data, client=self.client, curie_registry=self.curie_registry)
+
+
+class EntityObject(InteractiveApplicationResponse):
+    def __init__(self, data: dict, client: "ContentGridApplicationClient", curie_registry: CurieRegistry = None) -> None:
+        super().__init__(data, client, curie_registry)
+        self.id = data["id"]
+
+    def get_content_links(self) -> List[HALLink]:
+        return self.get_links("https://contentgrid.cloud/rels/contentgrid/content")
+
+    def get_relation_links(self) -> List[HALLink]:
+        return self.get_links("https://contentgrid.cloud/rels/contentgrid/relation")
+    
+    def get_relation_link(self, relation_name: str) -> HALLink:
+        relation_links = self.get_relation_links()
+        for relation_link in relation_links:
+            if relation_link.name == relation_name:
+                return relation_link
+        # If relation not found, raise exception.
+        raise NotFound(f"Relation {relation_name} not found on entity {self.get_self_link().uri}")
+
+    def get_relation_collection(self, relation_name : str, page: int = 0, size: int = 20, params: dict = {}):
+        params = self.client._add_page_and_size_to_params(page=page, size=size, params=params)
+        relation_link = self.get_relation_link(relation_name=relation_name)
+        return self.client.follow_link(relation_link, infer_type=EntityCollection, params=params)
+    
+    def put_relation(self, relation_name: str, related_entity_links : List[str | HALLink | Self]) -> None:
+        relation_link = self.get_relation_link(relation_name=relation_name)
+        relation_payload = self._create_text_uri_list_payload(links=related_entity_links)
+        response = self.client.put(relation_link.uri, headers={"Accept" : "*/*", "Content-Type" : "text/uri-list"}, data=relation_payload)
+        self.client._validate_non_json_response(response)
+
+    def post_relation(self, relation_name: str, related_entity_links : List[str | HALLink | Self]) -> None:
+        relation_link = self.get_relation_link(relation_name=relation_name)
+        relation_payload = self._create_text_uri_list_payload(links=related_entity_links)
+        response = self.client.post(relation_link.uri, headers={"Accept" : "*/*", "Content-Type" : "text/uri-list"}, data=relation_payload)
+        self.client._validate_non_json_response(response)
+
+    def put_data(self, data: dict, attribute_validation=True) -> None:
+        self.client._transform_hal_links_to_uris(attributes=data)
+        if attribute_validation:
+            self.client._validate_params(self.templates["default"], attributes=data)
+        return super().put_data(data)
+    
+    def patch_data(self, data : dict, attribute_validation=True ) -> None:
+        self.client._transform_hal_links_to_uris(attributes=data)
+        if attribute_validation:
+            self.client._validate_params(self.templates["default"], attributes=data)
+        return super().patch_data(data)
+    
+    def put_content_attribute(self, content_attribute_name : str, filepath : str) -> HALLink:
+        content_links = self.get_content_links()
+        if len(content_links) > 0:
+            for content_link in content_links:
+                if content_link.name == content_attribute_name:
+                    return self.client.put_on_content_link(content_link=content_link, filepath=filepath)
+        raise NotFound(f"Content Attribute {content_attribute_name} not found on entity {self.get_self_link().uri}")
+
+    def fetch_content_attribute_by_name(self, content_attribute_name : str) -> tuple[str, bytes]:
+        content_links = self.get_content_links()
+        if len(content_links) > 0:
+            for content_link in content_links:
+                if content_link.name == content_attribute_name:
+                    return self.client.fetch_content_attribute(content_link=content_link)
+        raise NotFound(f"Content Attribute {content_attribute_name} not found on entity {self.get_self_link().uri}")
+
+    def fetch_all_content_attributes(self) -> List[tuple[str, bytes]]:
+        files = []
+        for hal_content_link in self.get_content_links():
+            if self.metadata[hal_content_link.name] != None:
+                files.append(self.client.fetch_content_attribute(hal_content_link))
+        return files
+
+    def _create_text_uri_list_payload(self, links : List[str | HALLink | HALResponse]) -> str:
+        uri_list = []
+        for link in links:
+            if isinstance(link, HALLink):
+                uri_list.append(link.uri)
+            elif isinstance(link, HALResponse):
+                uri_list.append(link.get_self_link().uri)
+            elif isinstance(link, str):
+                uri_list.append(link)
+            else:
+                raise BadRequest(f"Incorrect Link type {type(link)} in uri list payload, allowed types: HALLink, HALResponse or str")
+        return "\n".join(uri_list)
+    
+class Profile(InteractiveHALResponse):
+    def __init__(self, data: dict, client: HALFormsClient, curie_registry: CurieRegistry = None) -> None:
+        super().__init__(data, client, curie_registry)
+    
+    def get_entity_links(self) -> List[HALLink]:
+        return self.get_links("https://contentgrid.cloud/rels/contentgrid/entity")
+    
+    def get_entity_profile(self, pluralized_entity_name: str):
+        pluralized_entity_names = [entityprofile.name for entityprofile in self.get_entity_links()]
+        if pluralized_entity_name in pluralized_entity_names:
+            for entity_profile_link in self.get_entity_links():
+                if entity_profile_link.name == pluralized_entity_name:
+                    return self.client.follow_link(entity_profile_link, expect_json=True)
+        else:
+            raise NotFound(f"Entity {pluralized_entity_name} does not exist.")
+    
+class PageInfo:
+    def __init__(self, size : int, total_elements : int, total_pages : int, number : int) -> None:
+        self.size : int = size
+        self.total_elements : int = total_elements
+        self.total_pages : int = total_pages
+        self.number : int = number
+
+class ContentGridApplicationClient(HALFormsClient):
+    def __init__(self,
+        client_endpoint: str,
+        auth_uri: str = None,
+        client_id: str = None,
+        client_secret: str = None,
+        token: str = None,
+        attribute_validation : bool = True,
+        session_cookie: str = None,
+        pool_maxsize : int = 10,
+    ) -> None:
+        logging.info("Initializing ContentGridApplicationClient...")
+        super().__init__(client_endpoint=client_endpoint, auth_uri=auth_uri, client_id=client_id, client_secret=client_secret, token=token, session_cookie=session_cookie, pool_maxsize=pool_maxsize)
+        self.attribute_validation = attribute_validation
+
+    def get_profile(self) -> Profile:
+        response = self.get("/profile", headers={"Accept": "application/json"})
+        data = self._validate_json_response(response)
+        return Profile(data, client=self)
+    
+    def get_entity_profile(self, pluralized_entity_name : str) -> HALResponse:
+        return self.get_profile().get_entity_profile(pluralized_entity_name=pluralized_entity_name)
+        
+    def fetch_openapi_yaml(self) -> tuple[str, bytes]:
+        res = self.get("/openapi.yml")
+        self._validate_non_json_response(res)
+        return ("openapi.yml", res.content)
+
+    def get_entity_collection(self, plural_entity_name: str, page: int = 0, size: int = 20, params: dict = {}) -> EntityCollection:
+        params = self._add_page_and_size_to_params(page=page, size=size, params=params)
+        response = self.get(plural_entity_name, params=params)
+        data = self._validate_json_response(response)
+        return EntityCollection(data, client=self)
+    
+    def create_entity(self, pluralized_entity_name: str, attributes:dict) -> EntityObject:
+        return self.get_entity_collection(plural_entity_name=pluralized_entity_name).create_entity(attributes=attributes, attribute_validation=self.attribute_validation)
+
+    def get_entity_instance(self, entity_link: HALLink | EntityObject) -> EntityObject:
+        if isinstance(entity_link, EntityObject):
+            return self.follow_link(entity_link.get_self_link(), infer_type=EntityObject)
+        elif isinstance(entity_link, HALLink):
+            return self.follow_link(entity_link, infer_type=EntityObject)
+        else:
+            raise BadRequest(f"entity_link should be of type EntityObject or HALLink. was type {type(entity_link)}")
+        
+    def get_entity_relation_collection(self, entity_link: HALLink, relation_name : str, page: int = 0, size: int = 20, params: dict = {}) -> EntityCollection:
+        return self.get_entity_instance(entity_link=entity_link).get_relation_collection(relation_name=relation_name, page=page, size=size, params=params)
+    
+    def put_entity_relation(self, entity_link: HALLink, relation_name: str, related_entity_links : List[str | HALLink | EntityObject]) -> None:
+        return self.get_entity_instance(entity_link=entity_link).put_relation(relation_name=relation_name, related_entity_links=related_entity_links)
+        
+    def post_entity_relation(self, entity_link: HALLink, relation_name: str, related_entity_links : List[str | HALLink | EntityObject]) -> None:
+        return self.get_entity_instance(entity_link=entity_link).post_relation(relation_name=relation_name, related_entity_links=related_entity_links)
+
+    def put_entity_attributes(self, entity_link: HALLink, attributes: dict) -> EntityObject:
+        entity = self.get_entity_instance(entity_link=entity_link)
+        entity.put_data(data=attributes, attribute_validation=self.attribute_validation)
+        return entity
+    
+    def patch_entity_attributes(self, entity_link: HALLink, attributes: dict) -> EntityObject:
+        entity = self.get_entity_instance(entity_link=entity_link)
+        entity.patch_data(data=attributes, attribute_validation=self.attribute_validation)
+        return entity
+
+    def put_content_attribute(self, entity_link: HALLink, content_attribute_name : str, filepath : str) -> HALLink:
+        return self.get_entity_instance(entity_link=entity_link).put_content_attribute(content_attribute_name=content_attribute_name, filepath=filepath)
+
+    def put_on_content_link(self, content_link:HALLink, filepath: str) -> HALLink:
+        if os.path.exists(filepath):
+            filename = filepath.split('/')[-1]
+            files = {'file': (filename, open(filepath, 'rb'), mimetypes.guess_type(filepath)[0])}
+        else:
+            raise BadRequest(f"Provided content not found {filepath}")
+        response = self.put(content_link.uri, files=files)
+        self._validate_non_json_response(response=response)
+        return content_link
+    
+    def fetch_content_attribute(self, content_link : HALLink) -> tuple[str, bytes]:
+        response = self.get(content_link.uri, headers={"Accept" : "*/*"})
+        self._validate_non_json_response(response=response)
+        content_disposition = response.headers.get('content-disposition')
+        
+        if content_disposition and content_disposition != "attachment":
+            filename = decode_header(content_disposition)[1][0].decode("utf-8")
+        else:
+            # If content-disposition header is not present, try to extract filename from URL
+            filename = os.path.basename(content_link.name)
+        return (filename, response.content)
+    
+    def fetch_all_content_attributes_from_entity_link(self, entity_link: HALLink) -> List[tuple[str, bytes]]:
+        return self.get_entity_instance(entity_link=entity_link).fetch_all_content_attributes()
+
+    def delete_link(self, link: HALLink) -> requests.Response:
+        response = self.delete(link.uri)
+        self._validate_non_json_response(response)
+        return response
+
+    def _validate_params(self, create_form : dict, attributes : dict, check_requirements : bool = True) -> None | Exception:
+        # Type checking
+        for attribute, value in attributes.items():
+            attribute_specs = list(filter(lambda spec : spec["name"] == attribute, create_form["properties"]))
+            if len(attribute_specs) == 1:
+                attribute_spec = attribute_specs[0]
+                multi_valued = False
+                if attribute_spec.get("options"):
+                    if "minItems" in attribute_spec["options"].keys() and attribute_spec["options"]["minItems"] == 0:
+                        if "maxItems" in attribute_spec["options"].keys() and attribute_spec["options"]["maxItems"] == 1:
+                            multi_valued = False
+                        else:
+                            multi_valued = True
+                if multi_valued:
+                    if type(value) == list:
+                        for v in value:
+                            if not hal_form_type_check[attribute_spec["type"]](v):
+                                raise IncorrectAttributeType(f"Attribute {attribute} has an incorrect type {type(value)} in its list value. {v} is not of type {hal_form_types[attribute_spec['type']]}")
+                    else:
+                        raise IncorrectAttributeType(f"Attribute {attribute} has an incorrect type {type(value)}. Should be of type list")
+                else:
+                    if not hal_form_type_check[attribute_spec["type"]](value):
+                        raise IncorrectAttributeType(f"Attribute {attribute} has an incorrect type {type(value)}. Should be of type {hal_form_types[attribute_spec['type']]}")
+            else:
+                logging.warning(f"Attribute {attribute} does not in exist in the entity hal forms specification")
+                #raise NonExistantAttribute(f"Attribute {attribute} does not in exist in the entity specification") 
+        
+        if check_requirements:
+            # Check for required properties is not needed when patching an entity
+            for attribute_spec in create_form["properties"]:
+                if attribute_spec.get("required"):
+                    if not attribute_spec["name"] in attributes.keys():
+                        raise MissingRequiredAttribute(f"Required attribute {attribute_spec['name']} not present in payload.")
+    

contentgrid_application_client-0.0.1/src/contentgrid_application_client.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: contentgrid-application-client
+Version: 0.0.1
+Summary: Python Client for interacting with ContentGrid Applications
+Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
+License: Copyright 2024 Xenit Solutions
+        
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        You may obtain a copy of the License at
+        
+            http://www.apache.org/licenses/LICENSE-2.0
+        
+        Unless required by applicable law or agreed to in writing, software
+        distributed under the License is distributed on an "AS IS" BASIS,
+        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+        See the License for the specific language governing permissions and
+        limitations under the License.
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: contentgrid-hal-client==0.0.1
+
+# ContentGrid Python Client
+
+This ContentGrid Client is a Python library designed to interact with ContentGrid API endpoints, specifically in the HAL response type. For ContentGrid Applications, it provides a convenient interface for performing various operations such as fetching profiles, creating entities, fetching related entities, handling content attributes, and more.
+
+## Features
+
+- **Profile Handling**: Fetch profiles to retrieve HAL-forms specification about available entities and their attributes.
+- **Entity Operations**: Create, fetch, update, and delete entities using a simple functions without needing to worry about headers and authentication.
+- **Content Handling**: Upload and download content on content-attributes of entities.
+- **Error Handling**: Provides basic error handling for network requests.
+- **Attribute validation**: Provides attribute type checks for creating and updating entities. Checks wether attributes have the correct type and if all required attributes are present.
+
+## Installation
+
+To install the ContentGrid API Client, you can use pip:
+
+```bash
+pip install contentgrid-application-client
+```
+
+## Usage
+
+### ContentGridApplicationClient
+```python
+from contentgrid-application-client import ContentGridApplicationClient
+
+# Initialize the client with service account
+client = ContentGridApplicationClient(
+    client_endpoint="https://b93ccecf-3466-44c0-995e-2620a8c66ac3.eu-west-1.contentgrid.cloud",
+    auth_uri="https://auth.eu-west-1.contentgrid.cloud/realms/cg-eade54da-3903-4554-aa5e-2982cd4126f1/protocol/openid-connect/token",
+    client_id="your_client_id",
+    client_secret="your_client_secret"
+)
+
+# Initialize the client with token
+client = ContentGridApplicationClient(
+    client_endpoint="https://b93ccecf-3466-44c0-995e-2620a8c66ac3.eu-west-1.contentgrid.cloud",
+    token="your_token"
+)
+
+# Fetch profile
+profile = client.get_profile()
+
+# Create entity
+attributes = {
+    "name": "Example Entity",
+    "description": "This is an example entity"
+}
+entity = client.create_entity("entity-name", attributes)
+```
+
+## Testing
+Installing requirements:
+```bash
+    pip install -r requirements.txt
+```
+
+Running tests: 
+
+```bash
+    python -m pytest
+```
+
+Running tests with coverage:
+
+```bash
+    coverage run -m pytest && coverage report -m
+```
+

contentgrid_application_client-0.0.1/src/contentgrid_application_client.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+pyproject.toml
+pytest.ini
+requirements.txt
+setup.py
+src/contentgrid_application_client/__init__.py
+src/contentgrid_application_client/application.py
+src/contentgrid_application_client.egg-info/PKG-INFO
+src/contentgrid_application_client.egg-info/SOURCES.txt
+src/contentgrid_application_client.egg-info/dependency_links.txt
+src/contentgrid_application_client.egg-info/requires.txt
+src/contentgrid_application_client.egg-info/top_level.txt
+tests/fixtures.py
+tests/test_collection.py
+tests/test_content.py
+tests/test_curies.py
+tests/test_entity_creation.py
+tests/test_hal_form_type_check.py
+tests/test_openapi.py
+tests/test_profile.py
+tests/test_relations.py
+tests/example-docs/document.jpg
+tests/example-docs/resume.pdf

contentgrid_application_client-0.0.1/src/contentgrid_application_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

contentgrid_application_client-0.0.1/src/contentgrid_application_client.egg-info/requires.txt

@@ -0,0 +1 @@
+contentgrid-hal-client==0.0.1

contentgrid_application_client-0.0.1/src/contentgrid_application_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+contentgrid_application_client

contentgrid_application_client-0.0.1/tests/fixtures.py

@@ -0,0 +1,34 @@
+from pytest import fixture
+import os
+from dotenv import load_dotenv
+
+from contentgrid_application_client import ContentGridApplicationClient
+
+load_dotenv(override=True)
+load_dotenv(".env.secret", override=True)
+
+CONTENTGRID_CLIENT_ENDPOINT = os.getenv("CONTENTGRID_CLIENT_ENDPOINT")
+CONTENTGRID_AUTH_URI = os.getenv("CONTENTGRID_AUTH_URI")
+
+# Service account
+CONTENTGRID_CLIENT_ID = os.getenv("CONTENTGRID_CLIENT_ID")
+CONTENTGRID_CLIENT_SECRET = os.getenv("CONTENTGRID_CLIENT_SECRET")
+
+contentgrid_client = ContentGridApplicationClient(
+    client_endpoint=CONTENTGRID_CLIENT_ENDPOINT,
+    auth_uri=CONTENTGRID_AUTH_URI,
+    client_id=CONTENTGRID_CLIENT_ID,
+    client_secret=CONTENTGRID_CLIENT_SECRET,
+)
+
+@fixture
+def cg_client() -> ContentGridApplicationClient:
+    return contentgrid_client
+
+@fixture
+def pdf_file_path() -> str:
+    return "contentgrid_application_client/tests/example-docs/resume.pdf"
+
+@fixture
+def img_file_path() -> str:
+    return "contentgrid_application_client/tests/example-docs/document.jpg"

contentgrid_application_client-0.0.1/tests/test_collection.py

@@ -0,0 +1,36 @@
+from contentgrid_application_client import ContentGridApplicationClient, EntityCollection, EntityObject
+from fixtures import cg_client
+
+def test_get_collection(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    entity_name = profile.get_entity_links()[0].name
+    collection_response = cg_client.get_entity_collection(entity_name)
+
+    assert type(collection_response) == EntityCollection
+    assert collection_response.page_info != None
+    assert collection_response.page_info.total_elements >= 0
+    assert collection_response.embedded != None
+    assert collection_response.links != None
+
+
+def test_get_entity(cg_client: ContentGridApplicationClient):
+    collection_response = cg_client.get_entity_collection(plural_entity_name="skills")
+
+    if collection_response.page_info.total_elements > 0:
+        for hal_object in collection_response.get_entities():
+            assert type(hal_object) == EntityObject
+            assert hal_object.id != None
+
+        example_entity_link = collection_response.get_entities()[0].get_self_link()
+        entity_object = cg_client.get_entity_instance(entity_link=example_entity_link)
+
+        assert type(entity_object) == EntityObject
+        assert entity_object.id != None
+        assert len(entity_object.metadata.keys()) > 0
+
+    if collection_response.page_info.total_pages > 0:
+        collection_response.first()
+        collection_response.next()
+        collection_response.prev()
+        collection_response.last()
+        assert type(collection_response) == EntityCollection

contentgrid_application_client-0.0.1/tests/test_content.py

@@ -0,0 +1,94 @@
+from contentgrid_application_client import ContentGridApplicationClient
+from contentgrid_hal_client.exceptions import BadRequest, NotFound
+from fixtures import cg_client, pdf_file_path, img_file_path
+import logging
+import os
+
+
+def test_add_content(
+    cg_client: ContentGridApplicationClient, pdf_file_path: str, img_file_path: str
+):
+    os.makedirs("output", exist_ok=True)
+    entity_name = "candidates"
+    logging.info("Creating test entity...")
+    entity = cg_client.create_entity(entity_name, attributes={"name": "test"})
+
+    has_failed = False
+    try:
+        cg_client.put_content_attribute(
+            entity_link=entity.get_self_link(),
+            content_attribute_name="test",
+            filepath=pdf_file_path,
+        )
+    except NotFound as e:
+        has_failed = True
+    assert has_failed
+
+    has_failed = False
+    try:
+        cg_client.put_content_attribute(
+            entity_link=entity.get_self_link(),
+            content_attribute_name="content",
+            filepath="test.pdf",
+        )
+    except BadRequest as e:
+        has_failed = True
+    assert has_failed
+
+    logging.info("Adding pdf content...")
+    contentlink = cg_client.put_content_attribute(
+        entity_link=entity.get_self_link(),
+        content_attribute_name="content",
+        filepath=pdf_file_path,
+    )
+    logging.info(contentlink.uri)
+    logging.info("validating that content exists")
+    filename, file = cg_client.fetch_content_attribute(
+        content_link=contentlink
+    )
+
+    filepath = os.path.join("output", filename)
+    with open(filepath, 'wb') as f:
+        f.write(file)
+
+    assert os.path.exists(filepath)
+
+    logging.info("Adding img content...")
+    contentlink = cg_client.put_on_content_link(
+        content_link=contentlink, filepath=img_file_path
+    )
+    logging.info(contentlink.uri)
+    logging.info("validating that content exists")
+    filename, file = cg_client.fetch_content_attribute(
+        content_link=contentlink
+    )
+
+    filepath = os.path.join("output", filename)
+    with open(filepath, 'wb') as f:
+        f.write(file)
+
+    assert os.path.exists(filepath)
+
+
+def test_add_multiple_content(
+    cg_client: ContentGridApplicationClient, pdf_file_path: str, img_file_path: str
+):
+    entity_name = "candidates"
+    logging.info("creating test entity...")
+    entity = cg_client.create_entity(entity_name, attributes={"name": "test"})
+    logging.info("Adding pdf content...")
+    contentlink = cg_client.put_content_attribute(
+        entity_link=entity.get_self_link(),
+        content_attribute_name="content",
+        filepath=pdf_file_path,
+    )
+    imglink = cg_client.put_content_attribute(
+        entity_link=entity.get_self_link(),
+        content_attribute_name="json_annotations",
+        filepath=img_file_path,
+    )
+    content_file_paths = cg_client.fetch_all_content_attributes_from_entity_link(entity_link=entity.get_self_link())
+    assert len(content_file_paths) == 2
+    cg_client.delete_link(entity.get_self_link())
+
+

contentgrid_application_client-0.0.1/tests/test_curies.py

@@ -0,0 +1,18 @@
+from typing import List
+from contentgrid_application_client import ContentGridApplicationClient
+from contentgrid_hal_client import HALLink
+from fixtures import cg_client
+
+
+def test_curies(cg_client:ContentGridApplicationClient):
+    entity_link_relation = "https://contentgrid.cloud/rels/contentgrid/entity"
+    profile = cg_client.get_profile()
+
+    entity_links : List[HALLink] = profile.get_entity_links()
+
+    assert len(entity_links) > 0
+    for entity_link in entity_links:
+        assert entity_link.link_relation == entity_link_relation
+
+    assert "cg:entity" == profile.curie_registry.compact_curie(entity_link_relation)
+    assert profile.curie_registry.expand_curie("cg:entity") == entity_link_relation

contentgrid_application_client-0.0.1/tests/test_entity_creation.py

@@ -0,0 +1,129 @@
+from contentgrid_application_client import (
+    ContentGridApplicationClient
+)
+from contentgrid_hal_client.exceptions import IncorrectAttributeType, MissingRequiredAttribute
+from fixtures import cg_client
+import logging
+
+default_values = {
+    "text": "test",
+    "datetime": "2024-03-18T15:25:54.838Z",
+    "checkbox": False,
+    "number": 10,
+}
+
+def test_create_update_entity(cg_client: ContentGridApplicationClient):
+    entity_name = "candidates"
+    text_attribute = "name"
+
+    candidates_profile = cg_client.get_entity_profile(entity_name)
+
+    attributes = {}
+
+    for property in candidates_profile.templates["create-form"]["properties"]:
+        if property["type"] in default_values.keys():
+            attributes[property["name"]] = default_values[property["type"]]
+
+    logging.info("Creating entity...")
+    entity = cg_client.create_entity(entity_name, attributes=attributes)
+    logging.info("Entity created.")
+
+    assert entity.metadata != None
+    assert entity.id != None
+    assert entity.get_self_link() != None
+
+    attributes[text_attribute] = "test-2"
+    logging.info("Updating attributes with PUT")
+    updated_entity = cg_client.put_entity_attributes(
+        entity_link=entity.get_self_link(), attributes=attributes
+    )
+    logging.info("Updating attributes with PATCH")
+    patched_entity = cg_client.patch_entity_attributes(
+        entity_link=updated_entity.get_self_link(),
+        attributes={text_attribute: "test-3"},
+    )
+    logging.info("done.")
+    assert entity.metadata[text_attribute] == "test"
+    assert updated_entity.metadata[text_attribute] == "test-2"
+    assert patched_entity.metadata[text_attribute] == "test-3"
+
+    logging.info("Deleting entity...")
+    cg_client.delete_link(entity.get_self_link())
+
+    entity_deleted = False
+    try:
+        cg_client.get_entity_instance(entity_link=entity.get_self_link())
+    except Exception as e:
+        logging.error(str(e))
+        entity_deleted = True
+
+    logging.info("Checking if entity is deleted")
+    assert entity_deleted
+
+
+def test_create_entity_required_relationship(cg_client: ContentGridApplicationClient):
+    entity_name = "anonymous-candidates"
+
+    test_candidate = cg_client.get_entity_collection(
+        plural_entity_name="candidates"
+    ).get_entities()[0]
+
+    attributes = {
+        "anonymized_name": "test-candidate",
+        "original": test_candidate.get_self_link(),
+    }
+
+    test_anon_candidate = cg_client.create_entity(entity_name, attributes=attributes)
+    cg_client.delete_link(test_anon_candidate.get_self_link())
+
+
+def test_create_entity_incorrect_params(cg_client: ContentGridApplicationClient):
+    entity_name = "anonymous-candidates"
+
+    threw_error = False
+    try:
+        cg_client.create_entity(entity_name, {"anonymized_name": 123})
+    except IncorrectAttributeType as e:
+        threw_error = True
+    except MissingRequiredAttribute as e:
+        threw_error = True
+
+    assert threw_error
+
+    test_candidate = cg_client.get_entity_collection(
+        plural_entity_name="candidates"
+    ).get_entities()[0]
+
+    threw_error = False
+    try:
+        entity = cg_client.create_entity(
+            entity_name,
+            {
+                "anonymized_name": 123,
+                "original": test_candidate.get_self_link(),
+            },
+        )
+    except IncorrectAttributeType as e:
+        threw_error = True
+    except MissingRequiredAttribute as e:
+        threw_error = True
+
+    assert threw_error
+
+    threw_error = False
+    try:
+        entity = cg_client.create_entity(
+            entity_name,
+            {
+                "anonymized_name": "test-candidate",
+                "original": test_candidate.get_self_link(),
+            },
+        )
+    except IncorrectAttributeType as e:
+        threw_error = True
+    except MissingRequiredAttribute as e:
+        threw_error = True
+
+    assert not threw_error
+
+    cg_client.delete_link(entity.get_self_link())

contentgrid_application_client-0.0.1/tests/test_hal_form_type_check.py

@@ -0,0 +1,20 @@
+from contentgrid_application_client import hal_form_type_check
+
+
+def test_hal_from_type_check():
+    number = 12
+    boolean = True
+    string = "test"
+    url = "https://b93ccecf-3466-44c0-995e-2620a8c66ac3.eu-west-1.contentgrid.cloud/skills/b4d84ca3-b436-4522-a1c3-71aaaf6f73ce"
+    datetime = "2024-03-20T16:48:59.904Z"
+
+    assert hal_form_type_check["text"](string)
+    assert hal_form_type_check["datetime"](datetime)
+    assert hal_form_type_check["checkbox"](boolean)
+    assert hal_form_type_check["number"](number)
+    assert hal_form_type_check["url"](url)
+
+    assert not hal_form_type_check["text"](number)
+    assert not hal_form_type_check["number"](string)
+    assert not hal_form_type_check["checkbox"]("true")
+    assert not hal_form_type_check["datetime"]("2024-03-20")

contentgrid_application_client-0.0.1/tests/test_openapi.py

@@ -0,0 +1,12 @@
+from contentgrid_application_client import ContentGridApplicationClient
+from fixtures import cg_client
+import os
+
+
+def test_fetch_openapi_spec(cg_client: ContentGridApplicationClient):
+    filename, file = cg_client.fetch_openapi_yaml()
+    os.makedirs("output", exist_ok=True)
+    output_path = os.path.join("output", filename)
+    with open(output_path, 'wb') as f:
+        f.write(file)
+    assert os.path.exists(output_path)

contentgrid_application_client-0.0.1/tests/test_profile.py

@@ -0,0 +1,24 @@
+from contentgrid_application_client import ContentGridApplicationClient, Profile
+from contentgrid_hal_client.exceptions import NotFound
+from fixtures import cg_client
+
+
+def test_get_profile(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    assert type(profile) == Profile
+    assert len(profile.get_entity_links()) > 0
+
+
+def test_get_specific_profile(cg_client: ContentGridApplicationClient):
+    profile = cg_client.get_profile()
+    entity_profile = cg_client.get_entity_profile(
+        profile.get_entity_links()[0].name
+    )
+    assert entity_profile.templates != None
+
+    has_failed = False
+    try:
+        cg_client.get_entity_profile("fadlfjaklsdjfhkladsf")
+    except NotFound as e:
+        has_failed = True
+    assert has_failed

contentgrid_application_client-0.0.1/tests/test_relations.py

@@ -0,0 +1,54 @@
+from contentgrid_application_client import ContentGridApplicationClient, EntityCollection
+from fixtures import cg_client
+import logging
+
+def test_relations(cg_client: ContentGridApplicationClient):
+    entity_name = "candidates"
+    relation_name = "skills"
+
+    entity = cg_client.create_entity(entity_name, {"name": "test"})
+
+    # fetch related skills
+    related_skills = cg_client.get_entity_relation_collection(
+        entity.get_self_link(), relation_name
+    )
+
+    assert type(related_skills) == EntityCollection
+
+    # entity just instantiated so no skills
+    assert len(related_skills.get_entities()) == 0
+
+    skills = cg_client.get_entity_collection("skills")
+
+    amt_skills_to_sample = 4
+    skills_selection = skills.get_entities()[:amt_skills_to_sample]
+    assert len(skills_selection) == amt_skills_to_sample
+
+    skills_selection[1] = skills_selection[1].get_self_link().uri
+    skills_selection[2] = skills_selection[2].get_self_link()
+
+    cg_client.put_entity_relation(
+        entity.get_self_link(),
+        relation_name=relation_name,
+        related_entity_links=skills_selection[:-1],
+    )
+
+    related_skills = cg_client.get_entity_relation_collection(
+        entity_link=entity.get_self_link(), relation_name=relation_name
+    )
+
+    assert len(related_skills.get_entities()) == amt_skills_to_sample - 1
+
+    # post last skill
+    cg_client.post_entity_relation(
+        entity_link=entity.get_self_link(),
+        relation_name=relation_name,
+        related_entity_links=[skills_selection[-1]],
+    )
+
+    related_skills = cg_client.get_entity_relation_collection(
+        entity_link=entity.get_self_link(), relation_name=relation_name
+    )
+    assert len(related_skills.get_entities()) == amt_skills_to_sample
+
+    cg_client.delete_link(entity.get_self_link())