personal_knowledge_library 3.1.2__py3-none-any.whl → 3.2.1__py3-none-any.whl

knowledge/services/graph.py

@@ -36,6 +36,7 @@ from knowledge.base.ontology import (
     ObjectProperty,
     EN_US,
 )
+from knowledge.base.response import JobStatus, ErrorLogResponse, NewEntityUrisResponse
 from knowledge.services import (
     AUTHORIZATION_HEADER_FLAG,
     APPLICATION_JSON_HEADER,
@@ -69,6 +70,7 @@ from knowledge.services import (
     DEFAULT_BACKOFF_FACTOR,
     ENTITIES_TAG,
     NEL_PARAM,
+    IndexType,
 )
 from knowledge.services.base import (
     WacomServiceAPIClient,
@@ -161,6 +163,7 @@ class WacomKnowledgeService(WacomServiceAPIClient):
     SEARCH_RELATION_ENDPOINT: str = "semantic-search/relation"
     ONTOLOGY_UPDATE_ENDPOINT: str = "ontology-update"
     IMPORT_ENTITIES_ENDPOINT: str = "import"
+    IMPORT_ERROR_LOG_ENDPOINT: str = "import/errorlog"
     REBUILD_VECTOR_SEARCH_INDEX: str = "vector-search/rebuild"
     REBUILD_NEL_INDEX: str = "nel/rebuild"
 
@@ -577,6 +580,127 @@ class WacomKnowledgeService(WacomServiceAPIClient):
             if not response.ok:
                 raise handle_error("Updating entity failed.", response)
 
+    def add_entity_indexes(
+        self,
+        entity_uri: str,
+        targets: List[IndexType],
+        auth_key: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        backoff_factor: float = DEFAULT_BACKOFF_FACTOR,
+    ) -> Dict[IndexType, Any]:
+        """
+        Updates index targets of an entity. The index targets can be set to "NEL", "ElasticSearch", "VectorSearchWord",
+        or "VectorSearchDocument".
+        If the target is already set for the entity, there will be no changes.
+
+        Parameters
+        ----------
+        entity_uri: str
+            URI of entity
+        targets: List[Literal["NEL", "ElasticSearch", "VectorSearchWord", "VectorSearchDocument"]]
+            List of indexing targets
+        auth_key: Optional[str]
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+        timeout: int
+            Timeout for the request (default: 60 seconds)
+        max_retries: int
+            Maximum number of retries
+        backoff_factor: float
+            A backoff factor to apply between attempts after the second try (most errors are resolved immediately by a
+            second try without a delay)
+
+        Returns
+        -------
+        update_status: Dict[str, Any]
+            Status per target (depending on the targets of entity and the ones set in the request). If the entity
+            already has the target set, the status will be "Target already exists" for that target,
+            otherwise it will be "UPSERT".
+
+        Raises
+        ------
+        WacomServiceException
+            If the graph service returns an error code
+        """
+        if auth_key is None:
+            auth_key, _ = self.handle_token()
+        url: str = f"{self.service_base_url}{WacomKnowledgeService.ENTITY_ENDPOINT}/{entity_uri}/indexes"
+        # Header info
+        headers: dict = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        mount_point: str = "https://" if self.service_url.startswith("https") else "http://"
+        with requests.Session() as session:
+            retries: Retry = Retry(total=max_retries, backoff_factor=backoff_factor, status_forcelist=STATUS_FORCE_LIST)
+            session.mount(mount_point, HTTPAdapter(max_retries=retries))
+            response: Response = session.patch(
+                url, json=targets, headers=headers, timeout=timeout, verify=self.verify_calls
+            )
+            if response.ok:
+                return response.json()
+            raise handle_error("Updating entity indexes failed.", response)
+
+    def remove_entity_indexes(
+        self,
+        entity_uri: str,
+        targets: List[IndexType],
+        auth_key: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        backoff_factor: float = DEFAULT_BACKOFF_FACTOR,
+    ) -> Dict[IndexType, Any]:
+        """
+        Deletes the search index for a given entity.
+
+        Parameters
+        ----------
+        entity_uri: str
+            URI of entity
+        targets: List[Literal["NEL", "ElasticSearch", "VectorSearchWord", "VectorSearchDocument"]]
+            List of indexing targets
+        auth_key: Optional[str]
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+        timeout: int
+            Timeout for the request (default: 60 seconds)
+        max_retries: int
+            Maximum number of retries
+        backoff_factor: float
+            A backoff factor to apply between attempts after the second try (most errors are resolved immediately by a
+            second try without a delay)
+
+        Returns
+        -------
+        update_status: Dict[str, Any]
+            Status per target (depending on the targets of entity and the ones set in the request), e.g.,
+            response will only contain {"NEL: "DELETE"}, if NEL is the only target in the request.
+
+        Raises
+        ------
+        WacomServiceException
+            If the graph service returns an error code
+        """
+        if auth_key is None:
+            auth_key, _ = self.handle_token()
+        url: str = f"{self.service_base_url}{WacomKnowledgeService.ENTITY_ENDPOINT}/{entity_uri}/indexes"
+        # Header info
+        headers: dict = {
+            USER_AGENT_HEADER_FLAG: self.user_agent,
+            CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
+            AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
+        }
+        mount_point: str = "https://" if self.service_url.startswith("https") else "http://"
+        with requests.Session() as session:
+            retries: Retry = Retry(total=max_retries, backoff_factor=backoff_factor, status_forcelist=STATUS_FORCE_LIST)
+            session.mount(mount_point, HTTPAdapter(max_retries=retries))
+            response: Response = session.delete(
+                url, json=targets, headers=headers, timeout=timeout, verify=self.verify_calls
+            )
+            if response.ok:
+                return response.json()
+            raise handle_error("Deleting entity indexes failed.", response)
+
     def relations(
         self,
         uri: str,
@@ -1685,10 +1809,8 @@ class WacomKnowledgeService(WacomServiceAPIClient):
 
         # Compress the NDJSON string to a gzip byte array
         compressed_data: bytes = gzip.compress(ndjson_content.encode("utf-8"))
-        with open("import.gzip", "wb") as f:
-            f.write(compressed_data)
         files: List[Tuple[str, Tuple[str, bytes, str]]] = [
-            ("file", ("import.njson", compressed_data, "application/x-gzip"))
+            ("file", ("import.njson.gz", compressed_data, "application/x-gzip"))
         ]
         url: str = f"{self.service_base_url}{self.IMPORT_ENTITIES_ENDPOINT}"
         mount_point: str = "https://" if self.service_url.startswith("https") else "http://"
@@ -1709,7 +1831,7 @@ class WacomKnowledgeService(WacomServiceAPIClient):
         timeout: int = DEFAULT_TIMEOUT,
         max_retries: int = DEFAULT_MAX_RETRIES,
         backoff_factor: float = DEFAULT_BACKOFF_FACTOR,
-    ) -> Dict[str, Any]:
+    ) -> JobStatus:
         """
         Retrieve the status of the job.
 
@@ -1729,7 +1851,7 @@ class WacomKnowledgeService(WacomServiceAPIClient):
 
         Returns
         -------
-        job_status: Dict[str, Any]
+        job_status: JobStatus
             Status of the job
         """
         if auth_key is None:
@@ -1742,7 +1864,105 @@ class WacomKnowledgeService(WacomServiceAPIClient):
             session.mount(mount_point, HTTPAdapter(max_retries=retries))
             response: Response = session.get(url, headers=headers, timeout=timeout, verify=self.verify_calls)
             if response.ok:
-                return response.json()
+                return JobStatus.from_dict(response.json())
+            raise handle_error(f"Retrieving job status for {job_id} failed.", response)
+
+    def import_error_log(
+        self,
+        job_id: str,
+        auth_key: Optional[str] = None,
+        next_page_id: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        backoff_factor: float = DEFAULT_BACKOFF_FACTOR,
+    ) -> ErrorLogResponse:
+        """
+        Retrieve the error log of the job.
+
+        Parameters
+        ----------
+        job_id: str
+            ID of the job
+        next_page_id: Optional[str] = None
+            ID of the next page within pagination.
+        auth_key: Optional[str] = None
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+        timeout: int
+            Timeout for the request (default: 60 seconds)
+        max_retries: int
+            Maximum number of retries
+        backoff_factor: float
+            A backoff factor to apply between attempts after the second try (most errors are resolved immediately by a
+            second try without a delay)
+
+        Returns
+        -------
+        error: ErrorLogResponse
+            Error log of the job
+        """
+        if auth_key is None:
+            auth_key, _ = self.handle_token()
+        headers: dict = {USER_AGENT_HEADER_FLAG: self.user_agent, AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}"}
+        url: str = f"{self.service_base_url}{self.IMPORT_ERROR_LOG_ENDPOINT}/{job_id}"
+        params: Dict[str, str] = {NEXT_PAGE_ID_TAG: next_page_id} if next_page_id else {}
+        mount_point: str = "https://" if self.service_url.startswith("https") else "http://"
+        with requests.Session() as session:
+            retries: Retry = Retry(total=max_retries, backoff_factor=backoff_factor, status_forcelist=STATUS_FORCE_LIST)
+            session.mount(mount_point, HTTPAdapter(max_retries=retries))
+            response: Response = session.get(
+                url, headers=headers, timeout=timeout, params=params, verify=self.verify_calls
+            )
+            if response.ok:
+                return ErrorLogResponse.from_dict(response.json())
+            raise handle_error(f"Retrieving job status for {job_id} failed.", response)
+
+    def import_new_uris(
+        self,
+        job_id: str,
+        auth_key: Optional[str] = None,
+        next_page_id: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        backoff_factor: float = DEFAULT_BACKOFF_FACTOR,
+    ) -> NewEntityUrisResponse:
+        """
+        Retrieve the new entity uris from the job.
+
+        Parameters
+        ----------
+        job_id: str
+            ID of the job
+        next_page_id: Optional[str] = None
+            ID of the next page within pagination.
+        auth_key: Optional[str] = None
+            If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
+        timeout: int
+            Timeout for the request (default: 60 seconds)
+        max_retries: int
+            Maximum number of retries
+        backoff_factor: float
+            A backoff factor to apply between attempts after the second try (most errors are resolved immediately by a
+            second try without a delay)
+
+        Returns
+        -------
+        response: NewEntityUrisResponse
+            New entity uris of the job.
+        """
+        if auth_key is None:
+            auth_key, _ = self.handle_token()
+        headers: dict = {USER_AGENT_HEADER_FLAG: self.user_agent, AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}"}
+        url: str = f"{self.service_base_url}{self.IMPORT_ENTITIES_ENDPOINT}/{job_id}/new-entities"
+        params: Dict[str, str] = {NEXT_PAGE_ID_TAG: next_page_id} if next_page_id else {}
+        mount_point: str = "https://" if self.service_url.startswith("https") else "http://"
+        with requests.Session() as session:
+            retries: Retry = Retry(total=max_retries, backoff_factor=backoff_factor, status_forcelist=STATUS_FORCE_LIST)
+            session.mount(mount_point, HTTPAdapter(max_retries=retries))
+            response: Response = session.get(
+                url, headers=headers, timeout=timeout, params=params, verify=self.verify_calls
+            )
+            if response.ok:
+                return NewEntityUrisResponse.from_dict(response.json())
             raise handle_error(f"Retrieving job status for {job_id} failed.", response)
 
     # ------------------------------------ Admin endpoints -------------------------------------------------------------

knowledge/services/ontology.py

@@ -9,6 +9,7 @@ from requests import Response
 from requests.adapters import HTTPAdapter
 from urllib3 import Retry
 
+from knowledge.base.entity import FORCE_TAG
 from knowledge.base.ontology import (
     OntologyClassReference,
     OntologyPropertyReference,
@@ -1140,6 +1141,7 @@ class OntologyService(WacomServiceAPIClient):
     def commit(
         self,
         context: str,
+        force: bool = False,
         auth_key: Optional[str] = None,
         timeout: int = DEFAULT_TIMEOUT,
         max_retries: int = DEFAULT_MAX_RETRIES,
@@ -1152,6 +1154,8 @@ class OntologyService(WacomServiceAPIClient):
         ----------
         context: str
             Name of the context.
+        force: bool (default:= False)
+            Force commit of the ontology.
         auth_key: Optional[str] [default:= None]
             If the auth key is set the logged-in user (if any) will be ignored and the auth key will be used.
         timeout: int
@@ -1170,11 +1174,13 @@ class OntologyService(WacomServiceAPIClient):
         }
         context_url: str = urllib.parse.quote_plus(context)
         url: str = f"{self.service_base_url}context/{context_url}/commit"
+        params: Dict[str, bool] = {FORCE_TAG: force}
         mount_point: str = "https://" if self.service_url.startswith("https") else "http://"
         with requests.Session() as session:
             retries: Retry = Retry(total=max_retries, backoff_factor=backoff_factor, status_forcelist=STATUS_FORCE_LIST)
             session.mount(mount_point, HTTPAdapter(max_retries=retries))
-            response: Response = session.put(url, headers=headers, verify=self.verify_calls, timeout=timeout)
+            response: Response = session.put(url, params=params, headers=headers, verify=self.verify_calls,
+                                             timeout=timeout)
             if not response.ok:
                 raise handle_error("Commit of ontology failed.", response, headers=headers)
 

knowledge/services/search.py

@@ -241,7 +241,7 @@ class SemanticSearchClient(WacomServiceAPIClient):
         """
         if auth_key is None:
             auth_key, _ = self.handle_token()
-        url: str = f"{self.service_base_url}documents/count/filter"
+        url: str = f"{self.service_base_url}documents/count/filter/"
         headers: Dict[str, str] = {
             USER_AGENT_HEADER_FLAG: self.user_agent,
             CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
@@ -309,7 +309,7 @@ class SemanticSearchClient(WacomServiceAPIClient):
             response = session.get(url, params=params, headers=headers)
             if response.ok:
                 return response.json().get("count", 0)
-        raise handle_error("Counting labels failed.", response, headers=headers, parameters={"locale": locale})
+            raise handle_error("Counting labels failed.", response, headers=headers, parameters={"locale": locale})
 
     def count_labels_filter(
         self,
@@ -347,7 +347,7 @@ class SemanticSearchClient(WacomServiceAPIClient):
         """
         if auth_key is None:
             auth_key, _ = self.handle_token()
-        url: str = f"{self.service_base_url}labels/count/filter"
+        url: str = f"{self.service_base_url}labels/count/filter/"
         headers: Dict[str, str] = {
             USER_AGENT_HEADER_FLAG: self.user_agent,
             CONTENT_TYPE_HEADER_FLAG: APPLICATION_JSON_HEADER,
@@ -360,9 +360,9 @@ class SemanticSearchClient(WacomServiceAPIClient):
             response = session.post(url, json={"locale": locale, "filter": filters}, headers=headers)
             if response.ok:
                 return response.json().get("count", 0)
-        raise handle_error(
-            "Counting labels failed.", response, headers=headers, parameters={"locale": locale, "filter": filters}
-        )
+            raise handle_error(
+                "Counting labels failed.", response, headers=headers, parameters={"locale": locale, "filter": filters}
+            )
 
     def document_search(
         self,

knowledge/services/tenant.py

@@ -224,11 +224,12 @@ class TenantManagementServiceAPI(WacomServiceAPIClient):
             CONTENT_TYPE_HEADER_FLAG: "application/json",
         }
         payload: dict = {
-            "rights": rights,
             "vectorSearchDataProperties": vector_search_data_properties,
             "vectorSearchObjectProperties": vector_search_object_properties,
             "contentDataPropertyName": content_data_property_name,
         }
+        if len(rights) > 0:
+            payload["rights"] = rights
         mount_point: str = "https://" if self.service_url.startswith("https") else "http://"
         with requests.Session() as session:
             retries: Retry = Retry(total=max_retries, backoff_factor=backoff_factor, status_forcelist=STATUS_FORCE_LIST)

knowledge/services/users.py

@@ -40,6 +40,8 @@ class UserRole(enum.Enum):
     """User only has control over his personal entities."""
     ADMIN = "TenantAdmin"
     """TenantAdmin has access to all entities independent of the access rights."""
+    CONTENT_MANAGER = "ContentManager"
+    """ContentManager is a special user for content accounts. The same visibility rules as for USER accounts apply."""
 
 
 USER_ROLE_MAPPING: Dict[str, UserRole] = {str(r.value): r for r in UserRole}