personal_knowledge_library 3.0.0__py3-none-any.whl

knowledge/__init__.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2021-present Wacom. All rights reserved.
+"""
+Personal knowledge Library
+--------------------------
+This library provides a set of tools to manage Wacom private knowledge graph API.
+All services are wrapped in a pythonic way to make it easy to use.
+Additionally, the library provides a set of tools to utilise Wikidata.
+"""
+import sys
+from datetime import datetime
+
+__author__ = "Markus Weber"
+__copyright__ = "Copyright 2021-present Wacom. All rights reserved."
+__credits__ = ["Markus Weber"]
+__license__ = "Wacom"
+__maintainer__ = ["Markus Weber"]
+__email__ = "markus.weber@wacom.com"
+__status__ = "beta"
+__version__ = "3.0.0"
+
+import loguru
+
+# Create the Logger
+logger = None
+
+if logger is None:
+    import logging
+    import inspect
+    from typing import Union
+
+    class InterceptHandler(logging.Handler):
+        """
+        Custom logging handler to redirect logs from the standard logging module to Loguru.
+        This handler intercepts log messages and forwards them to the Loguru logger.
+        """
+
+        def emit(self, record: logging.LogRecord) -> None:
+            # Get corresponding Loguru level if it exists.
+            try:
+                level: Union[str, int] = logger.level(record.levelname).name
+            except ValueError:
+                level = record.levelno
+
+            # Find caller from where originated the logged message.
+            frame, depth = inspect.currentframe(), 0
+            while frame:
+                filename = frame.f_code.co_filename
+                is_logging = filename == logging.__file__
+                is_frozen = "importlib" in filename and "_bootstrap" in filename
+                if depth > 0 and not (is_logging or is_frozen):
+                    break
+                frame = frame.f_back
+                depth += 1
+
+            logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+
+    logger = loguru.logger
+    logger.remove()
+    logger.info("Logger initialized in for pks tools.")
+    today = datetime.now()
+    logger.add(
+        sys.stderr,
+        colorize=True,
+        format="{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}",
+        level="INFO",
+        enqueue=True,
+    )
+    logging.basicConfig(handlers=[InterceptHandler()], level=0, force=True)
+
+__all__ = [
+    "__copyright__",
+    "__credits__",
+    "__license__",
+    "__maintainer__",
+    "__email__",
+    "__status__",
+    "__version__",
+    "logger",
+    "base",
+    "nel",
+    "public",
+    "services",
+    "utils",
+]
+
+from knowledge import base
+from knowledge import nel
+from knowledge import public
+from knowledge import services
+from knowledge import utils

knowledge/base/__init__.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2021-present Wacom. All rights reserved.
+"""
+Base structures.
+----------------
+This module provides the base structures for the knowledge graph.
+Such as the ontology, entities and access.
+
+The classes in this module are used by the knowledge graph service.
+For instance, the ontology structure is used to create the structure knowledge graph.
+The entities are used to store the knowledge graph.
+
+The access is used to access the knowledge graph, there are different types of access:
+    - Private access: the user can access only the entities that he/she created.
+    - Public access: the user can access all the entities.
+    - Group access: the user can access the entities that are in the same group.
+"""
+__all__ = ["access", "entity", "ontology"]
+
+from knowledge.base import access
+from knowledge.base import entity
+from knowledge.base import ontology

knowledge/base/access.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2021-present Wacom. All rights reserved.
+from typing import List
+
+
+class AccessRight:
+    """
+    Access rights for entities within a tenant.
+
+    Parameters
+    ----------
+    read: bool (default := False)
+        Read access for entity within tenant.
+    write: bool (default := False)
+        Write access for entity within tenant.
+    delete: bool (default := False)
+        Delete access for entity within tenant.
+    """
+
+    READ: str = "Read"
+    WRITE: str = "Write"
+    DELETE: str = "Delete"
+
+    def __init__(self, read: bool, write: bool, delete: bool):
+        self.__read: bool = read
+        self.__write: bool = write
+        self.__delete: bool = delete
+
+    @property
+    def read(self) -> bool:
+        """Read access for tenant."""
+        return self.__read
+
+    @read.setter
+    def read(self, value: bool):
+        self.__read = value
+
+    @property
+    def write(self) -> bool:
+        """Write access for tenant."""
+        return self.__write
+
+    @write.setter
+    def write(self, value: bool):
+        self.__write = value
+
+    @property
+    def delete(self) -> bool:
+        """Delete access for tenant."""
+        return self.__delete
+
+    @delete.setter
+    def delete(self, value: bool):
+        self.__delete = value
+
+    def __repr__(self):
+        result: str = "["
+        prefix: str = ""
+        if self.read:
+            result += AccessRight.READ
+            prefix = ", "
+        if self.write:
+            result += prefix + AccessRight.WRITE
+        if self.delete:
+            result += AccessRight.DELETE
+        result += "]"
+        return result
+
+    def to_list(self) -> List[str]:
+        """
+        Converts the access to list of properties.
+
+        Returns
+        -------
+        access_list: List[str]
+            List of rights
+        """
+        rights: List[str] = []
+        if self.read:
+            rights.append(TenantAccessRight.READ)
+        if self.write:
+            rights.append(TenantAccessRight.WRITE)
+        if self.delete:
+            rights.append(TenantAccessRight.DELETE)
+        return rights
+
+
+class TenantAccessRight(AccessRight):
+    """
+    TenantAccessRight
+    -----------------
+    Access rights for entities within a tenant.
+
+    Parameters
+    ----------
+    read: bool (default := False)
+        Read access for entity within tenant.
+    write: bool (default := False)
+        Write access for entity within tenant.
+    delete: bool (default := False)
+        Delete access for entity within tenant.
+    """
+
+    def __init__(self, read: bool = False, write: bool = False, delete: bool = False):
+        super().__init__(read, write, delete)
+
+    @classmethod
+    def parse(cls, param: List[str]) -> "TenantAccessRight":
+        """
+        Converts the access to list of properties.
+
+        Parameters
+        ----------
+        param: List[str]
+            List of rights
+
+        Returns
+        -------
+        tenant_rights: TenantAccessRight
+            Instantiated rights.
+        """
+        rights: TenantAccessRight = TenantAccessRight()
+        rights.read = TenantAccessRight.READ in param
+        rights.write = TenantAccessRight.WRITE in param
+        rights.delete = TenantAccessRight.DELETE in param
+        return rights
+
+
+class GroupAccessRight(AccessRight):
+    """
+    GroupAccessRight
+    -----------------
+    Group rights for entities within a group.
+
+    Parameters
+    ----------
+    read: bool (default := False)
+        Read access for entity within group.
+    write: bool (default := False)
+        Write access for entity within group.
+    delete: bool (default := False)
+        Delete access for entity within group.
+    """
+
+    def __init__(self, read: bool = False, write: bool = False, delete: bool = False):
+        super().__init__(read, write, delete)
+
+    @classmethod
+    def parse(cls, param: List[str]) -> "GroupAccessRight":
+        """
+        Converts the access to list of properties.
+
+        Parameters
+        ----------
+        param: List[str]
+            List of rights
+
+        Returns
+        -------
+        group_rights: GroupAccessRight
+            Instantiated rights.
+        """
+        rights: GroupAccessRight = GroupAccessRight()
+        rights.read = GroupAccessRight.READ in param
+        rights.write = GroupAccessRight.WRITE in param
+        rights.delete = GroupAccessRight.DELETE in param
+        return rights

knowledge/base/entity.py

@@ -0,0 +1,267 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2021-present Wacom. All rights reserved.
+import abc
+import enum
+from typing import Any, List, Dict, Union
+
+from knowledge.base.language import LocaleCode, LanguageCode, EN_US
+
+
+#  ---------------------------------------- Exceptions -----------------------------------------------------------------
+class ServiceException(Exception):
+    """Service exception."""
+
+
+class KnowledgeException(Exception):
+    """Knowledge exception."""
+
+
+#  ---------------------------------------- Constants ------------------------------------------------------------------
+RDF_SYNTAX_NS_TYPE: str = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+RDF_SCHEMA_COMMENT: str = "http://www.w3.org/2000/01/rdf-schema#comment"
+RDF_SCHEMA_LABEL: str = "http://www.w3.org/2000/01/rdf-schema#label"
+ALIAS_TAG: str = "alias"
+DATA_PROPERTY_TAG: str = "literal"
+VALUE_TAG: str = "value"
+LANGUAGE_TAG: str = "lang"
+LOCALE_TAG: str = "locale"
+DATA_PROPERTIES_TAG: str = "literals"
+SEND_TO_NEL_TAG: str = "sendToNEL"
+SEND_VECTOR_INDEX_TAG: str = "sendToVectorIndex"
+SOURCE_REFERENCE_ID_TAG: str = "source_reference_id"
+EXTERNAL_USER_ID_TAG: str = "external_user_id"
+SOURCE_SYSTEM_TAG: str = "source_system"
+OBJECT_PROPERTIES_TAG: str = "relations"
+OWNER_TAG: str = "owner"
+OWNER_ID_TAG: str = "ownerId"
+GROUP_IDS: str = "groupIds"
+LOCALIZED_CONTENT_TAG: str = "LocalizedContent"
+STATUS_FLAG_TAG: str = "status"
+CONTENT_TAG: str = "value"
+URI_TAG: str = "uri"
+URIS_TAG: str = "uris"
+FORCE_TAG: str = "force"
+ERRORS_TAG: str = "errors"
+TEXT_TAG: str = "text"
+TYPE_TAG: str = "type"
+IMAGE_TAG: str = "image"
+DESCRIPTION_TAG: str = "description"
+COMMENT_TAG: str = "text"
+COMMENTS_TAG: str = "comments"
+DESCRIPTIONS_TAG: str = "descriptions"
+REPOSITORY_TAG: str = "repository"
+DISPLAY_TAG: str = "display"
+USE_NEL_TAG: str = "use_for_nel"
+USE_VECTOR_INDEX_TAG: str = "use_for_vector_index"
+USE_VECTOR_DOCUMENT_INDEX_TAG: str = "use_for_vector_document_index"
+USE_FULLTEXT_TAG: str = "user_full_text"
+TARGETS_TAG: str = "targets"
+VISIBILITY_TAG: str = "visibility"
+RELATIONS_TAG: str = "relations"
+LABELS_TAG: str = "labels"
+IS_MAIN_TAG: str = "isMain"
+DATA_TYPE_TAG: str = "dataType"
+RELATION_TAG: str = "relation"
+OUTGOING_TAG: str = "out"
+INCOMING_TAG: str = "in"
+TENANT_RIGHTS_TAG: str = "tenantRights"
+INFLECTION_CONCEPT_CLASS: str = "concept"
+INFLECTION_SETTING: str = "inflection"
+INFLECTION_CASE_SENSITIVE: str = "caseSensitive"
+# ------------------------------------------ Indexing targets ----------------------------------------------------------
+INDEXING_NEL_TARGET: str = "NEL"
+INDEXING_VECTOR_SEARCH_TARGET: str = "VectorSearchWord"
+INDEXING_VECTOR_SEARCH_DOCUMENT_TARGET: str = "VectorSearchDocument"
+INDEXING_FULLTEXT_TARGET: str = "ElasticSearch"
+
+
+class EntityStatus(enum.Enum):
+    """
+    Entity Status
+    -------------
+    Status of the entity synchronization (client and knowledge graph).
+    """
+
+    UNKNOWN = 0
+    """Unknown status."""
+    CREATED = 1
+    """Entity has been created and not yet update."""
+    UPDATED = 2
+    """Entity has been updated by the client and must be synced."""
+    SYNCED = 3
+    """State of entity is in sync with knowledge graph."""
+
+
+class LocalizedContent(abc.ABC):
+    """
+    Localized content
+    -----------------
+    Content that is multilingual.
+
+    Parameters
+    ----------
+    content: str
+        Content value
+    language_code: LanguageCode (default:= 'en_US')
+        ISO-3166 Country Codes and ISO-639 Language Codes in the format '<language_code>_<country>', e.g., 'en_US'.
+    """
+
+    def __init__(self, content: str, language_code: Union[LocaleCode, LanguageCode]):
+        self.__content: str = content
+        self.__language_code: Union[LocaleCode, LanguageCode] = language_code
+
+    @property
+    def content(self) -> str:
+        """String representation of the content."""
+        return self.__content
+
+    @content.setter
+    def content(self, value: str):
+        self.__content = value
+
+    @property
+    def language_code(self) -> Union[LocaleCode, LanguageCode]:
+        """Locale"""
+        return self.__language_code
+
+    def __repr__(self):
+        return f"{self.content}@{self.language_code}"
+
+
+class Label(LocalizedContent):
+    """
+    Label
+    -----
+    Label that is multilingual.
+
+    Parameters
+    ----------
+    content: str
+        Content value
+    language_code: LocaleCode (default:= 'en_US')
+        ISO-3166 Country Codes and ISO-639 Language Codes in the format <language_code>_<country>, e.g., en_US.
+    main: bool (default:=False)
+        Main content
+    """
+
+    def __init__(self, content: str, language_code: LocaleCode = EN_US, main: bool = False):
+        self.__main: bool = main
+        super().__init__(content, language_code)
+
+    @property
+    def main(self) -> bool:
+        """Flag if the content is the  main content or an alias."""
+        return self.__main
+
+    @staticmethod
+    def create_from_dict(
+        dict_label: Dict[str, Any], tag_name: str = CONTENT_TAG, locale_name: str = LOCALE_TAG
+    ) -> "Label":
+        """
+        Create a label from a dictionary.
+        Parameters
+        ----------
+        dict_label: Dict[str, Any]
+            Dictionary containing the label information.
+        tag_name: str
+            Tag name of the content.
+        locale_name: str
+            Tag name of the language code.
+
+        Returns
+        -------
+        instance: Label
+            The Label instance.
+        """
+        if tag_name not in dict_label:
+            raise ValueError("Dict is does not contain a localized label.")
+        if locale_name not in dict_label:
+            raise ValueError("Dict is does not contain a language code")
+        if IS_MAIN_TAG in dict_label:
+            return Label(dict_label[tag_name], LocaleCode(dict_label[locale_name]), dict_label[IS_MAIN_TAG])
+        return Label(dict_label[tag_name], LocaleCode(dict_label[locale_name]))
+
+    @staticmethod
+    def create_from_list(param: List[dict]) -> List[LOCALIZED_CONTENT_TAG]:
+        """
+        Create a list of labels from a list of dictionaries.
+
+        Parameters
+        ----------
+        param: List[dict]
+            List of dictionaries containing the label information.
+
+        Returns
+        -------
+        instance: List[Label]
+            List of label instances.
+        """
+        return [Label.create_from_dict(p) for p in param]
+
+    def __dict__(self):
+        return {CONTENT_TAG: self.content, LOCALE_TAG: self.language_code, IS_MAIN_TAG: self.main}
+
+
+class Description(LocalizedContent):
+    """
+    Description
+    -----------
+    Description that is multilingual.
+
+    Parameters
+    ----------
+    description: str
+        Description value
+    language_code: LanguageCode (default:= 'en_US')
+        Language code of content
+    """
+
+    def __init__(self, description: str, language_code: LocaleCode = EN_US):
+        super().__init__(description, language_code)
+
+    @staticmethod
+    def create_from_dict(
+        dict_description: Dict[str, Any], tag_name: str = DESCRIPTION_TAG, locale_name: str = LOCALE_TAG
+    ) -> "Description":
+        """
+        Create a description from a dictionary.
+
+        Parameters
+        ----------
+        dict_description: Dict[str, Any]
+            Dictionary containing the description information.
+        tag_name: str
+            Tag name of the content.
+        locale_name:
+            Tag name of the language code.
+
+        Returns
+        -------
+        instance: Description
+            The description instance.
+        """
+        if tag_name not in dict_description or locale_name not in dict_description:
+            raise ValueError("Dict is does not contain a localized label.")
+        return Description(dict_description[tag_name], LocaleCode(dict_description[locale_name]))
+
+    @staticmethod
+    def create_from_list(param: List[Dict[str, Any]]) -> List["Description"]:
+        """Create a list of descriptions from a list of dictionaries.
+
+        Parameters
+        ----------
+        param: List[Dict[str, Any]]
+            List of dictionaries containing the description information.
+
+        Returns
+        -------
+        instance: List[Description]
+            List of description instances.
+        """
+        return [Description.create_from_dict(p) for p in param]
+
+    def __dict__(self):
+        return {
+            DESCRIPTION_TAG: self.content,
+            LOCALE_TAG: self.language_code,
+        }

knowledge/base/language.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# Copyright © 2024-present Wacom. All rights reserved.
+from typing import NewType, List, Dict
+
+#  ---------------------------------------- Type definitions -----------------------------------------------------------
+LanguageCode = NewType("LanguageCode", str)
+LocaleCode = NewType("LocaleCode", str)
+# ------------------------------------------------ Language codes ------------------------------------------------------
+EN_US: LocaleCode = LocaleCode("en_US")
+JA_JP: LocaleCode = LocaleCode("ja_JP")
+DE_DE: LocaleCode = LocaleCode("de_DE")
+BG_BG: LocaleCode = LocaleCode("bg_BG")
+FR_FR: LocaleCode = LocaleCode("fr_FR")
+IT_IT: LocaleCode = LocaleCode("it_IT")
+ES_ES: LocaleCode = LocaleCode("es_ES")
+EN: LanguageCode = LanguageCode("en")
+DE: LanguageCode = LanguageCode("de")
+BG: LanguageCode = LanguageCode("bg")
+JA: LanguageCode = LanguageCode("ja")
+FR: LanguageCode = LanguageCode("fr")
+IT: LanguageCode = LanguageCode("it")
+ES: LanguageCode = LanguageCode("es")
+# ----------------------------------------------------------------------------------------------------------------------
+SUPPORTED_LOCALES: List[LocaleCode] = [JA_JP, EN_US, DE_DE, BG_BG, FR_FR, IT_IT, ES_ES]
+SUPPORTED_LANGUAGES: List[LanguageCode] = [JA, EN, DE, BG, FR, IT, ES]
+LANGUAGE_LOCALE_MAPPING: Dict[LanguageCode, LocaleCode] = dict(list(zip(SUPPORTED_LANGUAGES, SUPPORTED_LOCALES)))
+LOCALE_LANGUAGE_MAPPING: Dict[LocaleCode, LanguageCode] = dict(list(zip(SUPPORTED_LOCALES, SUPPORTED_LANGUAGES)))