personal_knowledge_library 3.3.1__tar.gz → 3.4.0__tar.gz

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: personal_knowledge_library
-Version: 3.3.1
+Version: 3.4.0
 Summary: Library to access Wacom's Personal Knowledge graph.
 License-Expression: Apache-2.0
 License-File: LICENSE

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/knowledge/__init__.py

@@ -17,7 +17,7 @@ __license__ = "Wacom"
 __maintainer__ = ["Markus Weber"]
 __email__ = "markus.weber@wacom.com"
 __status__ = "beta"
-__version__ = "3.3.1"
+__version__ = "3.4.0"
 
 import loguru
 

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/knowledge/base/ontology.py

@@ -997,12 +997,12 @@ class OntologyProperty(OntologyObject):
         return self.__reference
 
     @property
-    def subproperty_of(self) -> OntologyPropertyReference:
+    def subproperty_of(self) -> Optional[OntologyPropertyReference]:
         """Reference to the super property"""
         return self.__subproperty_of
 
     @property
-    def inverse_property_of(self) -> OntologyPropertyReference:
+    def inverse_property_of(self) -> Optional[OntologyPropertyReference]:
         """Reference to the inverse property"""
         return self.__inverse_property_of
 
@@ -1494,7 +1494,7 @@ class Ontology:
         return f"<Ontology> : classes:= {self.classes}"
 
 
-class ThingObject(object):
+class ThingObject:
     """
     ThingObject
     -----------
@@ -2199,7 +2199,7 @@ class ThingObject(object):
             dict_object[TARGETS_TAG].append(INDEXING_VECTOR_SEARCH_TARGET)
         if self.use_vector_index_document:
             dict_object[TARGETS_TAG].append(INDEXING_VECTOR_SEARCH_DOCUMENT_TARGET)
-        if not self.use_full_text_index:
+        if self.use_full_text_index:
             dict_object[TARGETS_TAG].append(INDEXING_FULLTEXT_TARGET)
         if external_user_id:
             dict_object[EXTERNAL_USER_ID_TAG] = external_user_id
@@ -2260,7 +2260,7 @@ class ThingObject(object):
         use_nel: bool = entity.get(USE_NEL_TAG, False)
         use_vector_index: bool = entity.get(USE_VECTOR_INDEX_TAG, False)
         use_vector_index_document: bool = entity.get(USE_VECTOR_DOCUMENT_INDEX_TAG, False)
-        use_full_text_index: bool = entity.get(USE_FULLTEXT_TAG, True)
+        use_full_text_index: bool = entity.get(USE_FULLTEXT_TAG, False)
         # Vector index target
         if INDEXING_VECTOR_SEARCH_TARGET in entity.get(TARGETS_TAG, []):
             use_vector_index = True

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/knowledge/base/response.py

@@ -324,19 +324,19 @@ class NewEntityUrisResponse:
 
     Parameters
     ----------
-    new_entities_uris: List[str]
-        The list of URIs of new entities.
+    new_entities_uris: Dict[str, str]
+        The mapping of entity IDs to URIs (ref_id -> uri).
     next_page_id: Optional[str]
         Next page ID for pagination.
     """
 
-    def __init__(self, new_entities_uris: List[str], next_page_id: Optional[str]):
-        self._new_entities_uris: List[str] = new_entities_uris
+    def __init__(self, new_entities_uris: List[Dict[str, str]], next_page_id: Optional[str]):
+        self._new_entities_uris: Dict[str, str] = {entry["ref_id"]: entry["uri"] for entry in new_entities_uris}
         self._next_page_id: Optional[str] = next_page_id
 
     @property
-    def new_entities_uris(self) -> List[str]:
-        """The list the uris of new entities."""
+    def new_entities_uris(self) -> Dict[str, str]:
+        """The mapping of entity IDs to URIs."""
         return self._new_entities_uris
 
     @property

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/knowledge/base/search.py

@@ -435,12 +435,23 @@ class LabelMatchingResponse:
 
 class VectorDBDocument:
     """
-    VectorDBDocument
-    ================
-    SegmentedContent model for the vector database.
+    Represents a document stored in a vector database.
 
-    Properties
+    This class is used for handling documents with associated metadata within a vector
+    database. It provides properties to access the document's ID, content, URI, and
+    metadata, making it suitable for systems that manage search or retrieval of
+    semantic data in vectorized form.
+
+    Attributes
     ----------
+    id : str
+        A unique identifier for the document.
+    content : str
+        The textual content of the document.
+    uri : str
+        A URI associated with the document.
+    metadata : Dict[str, Any]
+        Additional metadata associated with the document.
     """
 
     def __init__(self, data: Dict[str, Any]):

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/knowledge/nel/base.py

@@ -181,7 +181,6 @@ class KnowledgeGraphEntity(NamedEntity):
         entity_type: EntityType = EntityType.PUBLIC_ENTITY,
         tokens: Optional[List[str]] = None,
         token_indexes: Optional[List[int]] = None,
-
     ):
         super().__init__(ref_text, start_idx, end_idx, entity_type)
         self.__source: EntitySource = source

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/knowledge/public/helper.py

@@ -12,7 +12,7 @@ from requests import Response
 from requests.adapters import HTTPAdapter
 from urllib3 import Retry
 
-from knowledge import logger
+from knowledge import logger, __version__
 from knowledge.public import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT, DEFAULT_BACKOFF_FACTOR, STATUS_FORCE_LIST
 
 
@@ -96,6 +96,14 @@ WIKIDATA_SPARQL_URL: str = "https://query.wikidata.org/sparql"
 WIKIDATA_SEARCH_URL: str = "https://www.wikidata.org/w/api.php"
 
 
+def user_agent() -> str:
+    """User agent."""
+    return (
+        f"Personal Knowledge Library(Public Knowledge Crawler)/{__version__}"
+        f"(+https://github.com/Wacom-Developer/personal-knowledge-library)"
+    )
+
+
 # --------------------------------------- Helper functions -------------------------------------------------------------
 def image_url(img: str, dpi: int = 500):
     """
@@ -301,6 +309,7 @@ def __waiting_request__(
         status_forcelist=STATUS_FORCE_LIST,  # HTTP status codes to retry on
         respect_retry_after_header=True,  # respect the Retry-After header
     )
+    header: Dict[str, str] = {"User-Agent": user_agent()}
 
     # Create a session and mount the retry adapter
     with requests.Session() as session:
@@ -308,7 +317,7 @@ def __waiting_request__(
         session.mount("https://", retry_adapter)
 
         # Make a request using the session
-        response: Response = session.get(url, timeout=timeout)
+        response: Response = session.get(url, headers=header, timeout=timeout)
 
         # Check the response status code
         if not response.ok:
@@ -364,7 +373,7 @@ def __waiting_multi_request__(
         )
     query: str = "|".join(checked_entity_ids)
     url: str = f"{base_url}{query}&format=json"
-
+    header: Dict[str, str] = {"User-Agent": user_agent()}
     # Define the retry policy
     retry_policy: Retry = Retry(
         total=max_retries,  # maximum number of retries
@@ -379,7 +388,7 @@ def __waiting_multi_request__(
         session.mount("https://", retry_adapter)
 
         # Make a request using the session
-        response: Response = session.get(url, timeout=timeout)
+        response: Response = session.get(url, headers=header, timeout=timeout)
 
         # Check the response status code
         if not response.ok:

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/knowledge/public/wikidata.py

@@ -877,7 +877,7 @@ class WikidataThing:
                             val = {"tabular": data_value["value"]}
                         elif data_type == "entity-schema":
                             val = {"id": data_value["value"]["id"]}
-                        elif data_type in ["wikibase-form", "musical-notation"]:
+                        elif data_type in {"wikibase-form", "musical-notation"}:
                             continue
                         else:
                             raise WikiDataAPIException(f"Data type: {data_type} not supported.")

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/knowledge/services/asyncio/base.py

@@ -286,7 +286,7 @@ class AsyncServiceAPIClient(RESTAPIClient):
         session: aiohttp.ClientSession
             Asynchronous session
         """
-        timeout: ClientTimeout = ClientTimeout(total=60)
+        timeout: ClientTimeout = ClientTimeout(total=DEFAULT_TIMEOUT)
         ssl_context: ssl.SSLContext = ssl.create_default_context(cafile=certifi.where())
         connector: aiohttp.TCPConnector = aiohttp.TCPConnector(ssl=ssl_context, resolver=cached_resolver)
         return aiohttp.ClientSession(

{personal_knowledge_library-3.3.1 → personal_knowledge_library-3.4.0}/knowledge/services/asyncio/graph.py

@@ -119,6 +119,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
     ONTOLOGY_UPDATE_ENDPOINT: str = "ontology-update"
     IMPORT_ENTITIES_ENDPOINT: str = "import"
     IMPORT_ERROR_LOG_ENDPOINT: str = "import/errorlog"
+    MAX_NUMBER_URIS: int = 40
 
     def __init__(
         self,
@@ -185,8 +186,13 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         thing: ThingObject = ThingObject.from_dict(e)
         return thing
 
-    async def entities(self, uris: List[str], locale: Optional[LocaleCode] = None, auth_key: Optional[str] = None) \
-            -> List[ThingObject]:
+    async def entities(
+        self,
+        uris: List[str],
+        locale: Optional[LocaleCode] = None,
+        auth_key: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
+    ) -> List[ThingObject]:
         """
         Retrieve entities information from personal knowledge, using the  URI as identifier.
 
@@ -200,6 +206,8 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
             ISO-3166 Country Codes and ISO-639 Language Codes in the format <language_code>_<country>, e.g., en_US.
         auth_key: Optional[str]
             Use a different auth key than the one from the client
+        timeout: int
+            Timeout in seconds. Default: 10 seconds.
 
         Returns
         -------
@@ -219,23 +227,25 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
             AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
         }
         things: List[ThingObject] = []
-        params: Dict[str, Any] = {
-            URIS_TAG: uris
-        }
-        if locale:
-            params[LOCALE_TAG] = locale
+
         async with AsyncServiceAPIClient.__async_session__() as session:
-            async with session.get(url, headers=headers, params=params, verify_ssl=self.verify_calls) as response:
-                if response.ok:
-                    entities: List[Dict[str, Any]] = await response.json()
-                    for e in entities:
-                        thing: ThingObject = ThingObject.from_dict(e)
-                        things.append(thing)
-                else:
-                    raise await handle_error(
-                        f"Retrieving of entities content failed. List of URIs: {uris}.", response,
-                        headers=headers
-                    )
+            for chunk in range(0, len(uris), AsyncWacomKnowledgeService.MAX_NUMBER_URIS):
+                subset = uris[chunk : chunk + AsyncWacomKnowledgeService.MAX_NUMBER_URIS]
+                params: Dict[str, Any] = {URIS_TAG: subset}
+                if locale:
+                    params[LOCALE_TAG] = locale
+                async with session.get(
+                    url, headers=headers, params=params, timeout=timeout, verify_ssl=self.verify_calls
+                ) as response:
+                    if response.ok:
+                        entities: List[Dict[str, Any]] = await response.json()
+                        for e in entities:
+                            thing: ThingObject = ThingObject.from_dict(e)
+                            things.append(thing)
+                    else:
+                        raise await handle_error(
+                            f"Retrieving of entities content failed. List of URIs: {uris}.", response, headers=headers
+                        )
         await asyncio.sleep(0.25 if self.use_graceful_shutdown else 0.0)
         # Create ThingObject
         return things
@@ -594,10 +604,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         return uri
 
     async def import_entities(
-        self,
-        entities: List[ThingObject],
-        auth_key: Optional[str] = None,
-        timeout: int = DEFAULT_TIMEOUT
+        self, entities: List[ThingObject], auth_key: Optional[str] = None, timeout: int = DEFAULT_TIMEOUT
     ) -> str:
         """Import entities to the graph.
 
@@ -645,10 +652,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
                 raise await handle_error("Import endpoint returns an error.", response)
 
     async def import_entities_from_file(
-            self,
-            file_path: Path,
-            auth_key: Optional[str] = None,
-            timeout: int = DEFAULT_TIMEOUT
+        self, file_path: Path, auth_key: Optional[str] = None, timeout: int = DEFAULT_TIMEOUT
     ) -> str:
         """Import entities from a file to the graph.
 
@@ -670,6 +674,8 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         ------
         WacomServiceException
             If the graph service returns an error code.
+        FileNotFoundError
+            If the file path does not exist.
         """
         if not file_path.exists():
             raise FileNotFoundError(f"The file {file_path} does not exist.")
@@ -680,12 +686,11 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
             # Compress the NDJSON string to a gzip byte array
             compressed_data: bytes = file.read()
             data: aiohttp.FormData = aiohttp.FormData()
-            data.add_field("file", compressed_data, filename="import.njson.gz",
-                           content_type="application/x-gzip")
+            data.add_field("file", compressed_data, filename="import.njson.gz", content_type="application/x-gzip")
             url: str = f"{self.service_base_url}{self.IMPORT_ENTITIES_ENDPOINT}"
             async with AsyncServiceAPIClient.__async_session__() as session:
                 async with session.post(
-                        url, headers=headers, data=data, timeout=timeout, verify_ssl=self.verify_calls
+                    url, headers=headers, data=data, timeout=timeout, verify_ssl=self.verify_calls
                 ) as response:
                     if response.ok:
                         structure: Dict[str, Any] = await response.json(loads=orjson.loads)
@@ -693,10 +698,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
                     raise await handle_error("Import endpoint returns an error.", response)
 
     async def job_status(
-            self,
-            job_id: str,
-            auth_key: Optional[str] = None,
-            timeout: int = DEFAULT_TIMEOUT
+        self, job_id: str, auth_key: Optional[str] = None, timeout: int = DEFAULT_TIMEOUT
     ) -> JobStatus:
         """
         Retrieve the status of the job.
@@ -720,20 +722,18 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         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}"
         async with AsyncServiceAPIClient.__async_session__() as session:
-            async with session.get(
-                    url, headers=headers, timeout=timeout, verify_ssl=self.verify_calls
-            ) as response:
+            async with session.get(url, headers=headers, timeout=timeout, verify_ssl=self.verify_calls) as response:
                 if response.ok:
                     structure: Dict[str, Any] = await response.json(loads=orjson.loads)
                     return JobStatus.from_dict(structure)
                 raise await handle_error(f"Retrieving job status for {job_id} failed.", response, headers=headers)
 
     async def import_error_log(
-            self,
-            job_id: str,
-            auth_key: Optional[str] = None,
-            next_page_id: Optional[str] = None,
-            timeout: int = DEFAULT_TIMEOUT
+        self,
+        job_id: str,
+        auth_key: Optional[str] = None,
+        next_page_id: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
     ) -> ErrorLogResponse:
         """
         Retrieve the error log of the job.
@@ -761,7 +761,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         params: Dict[str, str] = {NEXT_PAGE_ID_TAG: next_page_id} if next_page_id else {}
         async with AsyncServiceAPIClient.__async_session__() as session:
             async with session.get(
-                    url, headers=headers, params=params, timeout=timeout, verify_ssl=self.verify_calls
+                url, headers=headers, params=params, timeout=timeout, verify_ssl=self.verify_calls
             ) as response:
                 if response.ok:
                     structure: Dict[str, Any] = await response.json(loads=orjson.loads)
@@ -769,11 +769,11 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
                 raise await handle_error(f"Retrieving job status for {job_id} failed.", response)
 
     async def import_new_uris(
-            self,
-            job_id: str,
-            auth_key: Optional[str] = None,
-            next_page_id: Optional[str] = None,
-            timeout: int = DEFAULT_TIMEOUT
+        self,
+        job_id: str,
+        auth_key: Optional[str] = None,
+        next_page_id: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
     ) -> NewEntityUrisResponse:
         """
         Retrieve the new entity uris from the job.
@@ -801,15 +801,14 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         params: Dict[str, str] = {NEXT_PAGE_ID_TAG: next_page_id} if next_page_id else {}
         async with AsyncServiceAPIClient.__async_session__() as session:
             async with session.get(
-                    url, headers=headers, params=params, timeout=timeout, verify_ssl=self.verify_calls
+                url, headers=headers, params=params, timeout=timeout, verify_ssl=self.verify_calls
             ) as response:
                 if response.ok:
                     structure: Dict[str, Any] = await response.json(loads=orjson.loads)
                     return NewEntityUrisResponse.from_dict(structure)
                 raise await handle_error(f"Retrieving job status for {job_id} failed.", response)
 
-
-    async def update_entity(self, entity: ThingObject, auth_key: Optional[str] = None):
+    async def update_entity(self, entity: ThingObject, auth_key: Optional[str] = None, timeout: int = DEFAULT_TIMEOUT):
         """
         Updates entity in graph.
 
@@ -819,6 +818,8 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
             entity object
         auth_key: Optional[str]
             Use a different auth key than the one from the client
+        timeout: int
+            Timeout in seconds. Default: 10 seconds.
 
         Raises
         ------
@@ -838,7 +839,11 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         payload: Dict[str, Any] = await AsyncWacomKnowledgeService.__entity__(entity)
         async with AsyncServiceAPIClient.__async_session__() as session:
             async with session.patch(
-                url, json=payload, headers=headers, timeout=DEFAULT_TIMEOUT, verify_ssl=self.verify_calls
+                url,
+                json=payload,
+                headers=headers,
+                timeout=timeout,
+                verify_ssl=self.verify_calls,
             ) as response:
                 if not response.ok:
                     raise await handle_error(
@@ -962,7 +967,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         return response_dict
 
     async def relations(
-        self, uri: str, auth_key: Optional[str] = None
+        self, uri: str, auth_key: Optional[str] = None, timeout: int = DEFAULT_TIMEOUT
     ) -> Dict[OntologyPropertyReference, ObjectProperty]:
         """
         Retrieve the relations (object properties) of an entity.
@@ -975,6 +980,9 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         auth_key: Optional[str]
             Use a different auth key than the one from the client
 
+        timeout: int
+            Request timeout in seconds (default: 60 seconds)
+
         Returns
         -------
         relations: Dict[OntologyPropertyReference, ObjectProperty]
@@ -996,7 +1004,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
             AUTHORIZATION_HEADER_FLAG: f"Bearer {auth_key}",
         }
         async with AsyncServiceAPIClient.__async_session__() as session:
-            async with session.get(url, headers=headers, verify_ssl=self.verify_calls) as response:
+            async with session.get(url, headers=headers, verify_ssl=self.verify_calls, timeout=timeout) as response:
                 if response.ok:
                     rel: list = (await response.json(loads=orjson.loads)).get(RELATIONS_TAG)
                 else:
@@ -1131,7 +1139,11 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         await asyncio.sleep(0.250 if self.use_graceful_shutdown else 0)
 
     async def create_relations_bulk(
-        self, source: str, relations: Dict[OntologyPropertyReference, List[str]], auth_key: Optional[str] = None
+        self,
+        source: str,
+        relations: Dict[OntologyPropertyReference, List[str]],
+        auth_key: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
     ):
         """
         Creates all the relations for an entity to a source entity.
@@ -1147,6 +1159,9 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         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
+            Request timeout in seconds (default: 60 seconds)
+
         Raises
         ------
         WacomServiceException
@@ -1159,7 +1174,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         async with AsyncServiceAPIClient.__async_session__() as session:
             for update_bulk in split_updates(relations):
                 async with session.post(
-                    url, json=update_bulk, headers=headers, verify_ssl=self.verify_calls
+                    url, json=update_bulk, headers=headers, verify_ssl=self.verify_calls, timeout=timeout
                 ) as response:
                     if not response.ok:
                         raise await handle_error(
@@ -1171,7 +1186,12 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         await asyncio.sleep(0.250 if self.use_graceful_shutdown else 0)
 
     async def remove_relation(
-        self, source: str, relation: OntologyPropertyReference, target: str, auth_key: Optional[str] = None
+        self,
+        source: str,
+        relation: OntologyPropertyReference,
+        target: str,
+        auth_key: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
     ):
         """
         Removes a relation.
@@ -1186,6 +1206,8 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
             Entities uri of the target
         auth_key: Optional[str] [default:=None]
             Use a different auth key than the one from the client
+        timeout: int
+            Request timeout in seconds (default: 60 seconds)
 
         Raises
         ------
@@ -1202,7 +1224,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         }
         async with AsyncServiceAPIClient.__async_session__() as session:
             async with session.delete(
-                url, params=params, headers=headers, timeout=DEFAULT_TIMEOUT, verify_ssl=self.verify_calls
+                url, params=params, headers=headers, timeout=timeout, verify_ssl=self.verify_calls
             ) as response:
                 if not response.ok:
                     raise await handle_error(
@@ -1211,7 +1233,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         await asyncio.sleep(0.250 if self.use_graceful_shutdown else 0)
 
     async def activations(
-        self, uris: List[str], depth: int, auth_key: Optional[str] = None
+        self, uris: List[str], depth: int, auth_key: Optional[str] = None, timeout: int = DEFAULT_TIMEOUT
     ) -> Tuple[Dict[str, ThingObject], List[Tuple[str, OntologyPropertyReference, str]]]:
         """
         Spreading activation, retrieving the entities related to an entity.
@@ -1224,6 +1246,8 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
             Depth of activations
         auth_key: Optional[str] [default:=None]
             Use a different auth key than the one from the client
+        timeout: int
+            Request timeout in seconds (default: 60 seconds)
 
         Returns
         -------
@@ -1247,7 +1271,9 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         params: dict = {URIS_TAG: uris, ACTIVATION_TAG: depth}
 
         async with AsyncServiceAPIClient.__async_session__() as session:
-            async with session.get(url, headers=headers, params=params, verify_ssl=self.verify_calls) as response:
+            async with session.get(
+                url, headers=headers, params=params, verify_ssl=self.verify_calls, timeout=timeout
+            ) as response:
                 if response.ok:
                     entities: Dict[str, Any] = await response.json(loads=orjson.loads)
                     things: Dict[str, ThingObject] = {
@@ -1276,6 +1302,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         is_owner: Optional[bool] = None,
         estimate_count: bool = False,
         auth_key: Optional[str] = None,
+        timeout: int = DEFAULT_TIMEOUT,
     ) -> Tuple[List[ThingObject], int, str]:
         """
         List all entities visible to users.
@@ -1298,6 +1325,8 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
             Request an estimate of the entities in a tenant.
         auth_key: Optional[str]
             Auth key from user if not set, the client auth key will be used
+        timeout: int
+            Timeout for the request (default: 60 seconds)
 
         Returns
         -------
@@ -1338,7 +1367,9 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
             parameters[NEXT_PAGE_ID_TAG] = page_id
         async with AsyncServiceAPIClient.__async_session__() as session:
             # Send request
-            async with session.get(url, params=parameters, headers=headers, verify_ssl=self.verify_calls) as response:
+            async with session.get(
+                url, params=parameters, headers=headers, verify_ssl=self.verify_calls, timeout=timeout
+            ) as response:
                 # If response is successful
                 if response.ok:
                     entities_resp: Dict[str, Any] = await response.json(loads=orjson.loads)
@@ -1400,7 +1431,7 @@ class AsyncWacomKnowledgeService(AsyncServiceAPIClient):
         next_page_id: str = None,
         auth_key: Optional[str] = None,
     ) -> Tuple[List[ThingObject], str]:
-        """Search term in labels, literals and description.
+        """Search term in labels, literals, and description.
 
         Parameters
         ----------