kognitos-bdk-api 1.12.4__tar.gz

kognitos_bdk_api-1.12.4/LICENSE

@@ -0,0 +1,45 @@
+Copyright © 2024 Kognitos, Inc. (“Licensor”)
+
+ACCEPTANCE
+By using or accessing the Software, you (including any legal entity, sole proprietorship, or organization that you 
+work for, as well as any affiliates under common control therewith, collectively “Licensee”) agree to be bound by the 
+terms of this License and assume full responsibility for all direct or indirect use of the Software.
+
+COPYRIGHT LICENSE
+Subject to Licensee’s full compliance with this License, including the limitations and conditions set forth herein or 
+in any other applicable documentation provided by Licensor, Licensor grants Licensee a non-exclusive, royalty-free, 
+worldwide, non-sublicensable, and non-transferable license to access, use, copy, distribute, make available, and 
+prepare derivative works of the Software. No rights or licenses are granted beyond those expressly stated in this 
+License.
+
+LIMITATIONS
+Licensee agrees not to use the Software beyond the scope explicitly authorized under this License. By accessing the 
+Software, either directly or on behalf of your organization, Licensee further agrees not to: (i) use the Software for 
+purposes that are directly competitive with Licensor’s business activities; (ii) provide the Software to third parties
+as a hosted or managed service that enables access to substantial features or functionality of the Software; 
+(iii) rent, lease, lend, sell, sublicense, assign, distribute, publish, transfer, or otherwise make the Software 
+available to any third party, or disable or circumvent any technological measures included with the Software; 
+(iv) alter, remove, obscure, or fail to display any copyright, licensing, or other proprietary notices included 
+with the Software; or (v) use the Software in any manner that infringes, misappropriates, or otherwise violates 
+any intellectual property rights or other rights of any person, or that violates any applicable laws or regulations.
+All copies of the original Software, modified Software, and derivative works are subject to this License or other 
+applicable documentation provided by Licensor. Licensee must ensure that any party receiving a copy of any part 
+of the Software from Licensee also receives a copy of these terms. Any violation of the terms of this Licensee will 
+result in the immediate and permanent termination of all rights under this License.
+
+INFRINGEMENT CLAIMS
+This License does not extend to intellectual property claims caused by modifications or additions made by Licensee 
+to the Software. If Licensee or their organization asserts in writing that the Software infringes or contributes 
+to the infringement of any patent, all rights granted under this License will terminate immediately. In the event 
+that the assertion is made by an organization, termination will extend to all uses of the Software on behalf of 
+the organization.
+
+NO LIABILITY
+Except as expressly stated in this License, no other rights are granted. To the maximum extent permitted by applicable 
+law, the Software is provided “as is,” without warranties or conditions of any kind, express or implied, including 
+but not limited to warranties of merchantability, fitness for a particular purpose, or non-infringement. Licensor 
+shall not be liable for any damages arising from these terms or from the use of the Software under any legal theory.
+To the maximum extent permitted by applicable law, the Software is provided “as is,” without warranties of any kind. 
+Licensor shall not be liable for any damages, including but not limited to direct, indirect, incidental, special, 
+consequential, or exemplary damages, arising from these terms or the use of the Software, regardless of the legal 
+theory invoked.

kognitos_bdk_api-1.12.4/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: kognitos-bdk-api
+Version: 1.12.4
+Summary: Kognitos Book Development Kit
+License: Proprietary
+Author: Emiliano Lesende
+Author-email: emiliano@kognitos.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: attrs
+Requires-Dist: attrs (>=24.2.0,<25.0.0) ; extra == "attrs"
+Requires-Dist: docstring-parser (>=0.15,<0.16)
+Requires-Dist: kognitos-bdk-klang (>=2.0.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# Python API for Book Development Kit
+ 
+This package serves as a Python API tailored for the creation of books.
+

kognitos_bdk_api-1.12.4/README.md

@@ -0,0 +1,3 @@
+# Python API for Book Development Kit
+ 
+This package serves as a Python API tailored for the creation of books.

kognitos_bdk_api-1.12.4/pyproject.toml

@@ -0,0 +1,77 @@
+[tool.poetry]
+name = "kognitos-bdk-api"
+version = "1.12.4"
+description = "Kognitos Book Development Kit"
+authors = ["Emiliano Lesende <emiliano@kognitos.com>"]
+readme = "README.md"
+license = "Proprietary"
+packages = [{include = "kognitos", from="src"}]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+
+[tool.poetry.dependencies]
+python = ">=3.11,<4.0"
+docstring-parser = "^0.15"
+kognitos-bdk-klang = "^2.0.0"
+attrs = {version="^24.2.0", optional=true}
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.4.4"
+mypy = "^1.8.0"
+isort = "^5.13.2"
+black = "^24.2.0"
+pre-commit = "^3.6.2"
+pylint = "^3.1.0"
+pyright = "^1.1.360"
+pytest-cov = "^5.0.0"
+attrs = "^24.2.0"
+pyarrow = "^17.0.0"
+arro3-core = "^0.4.2"
+nanoarrow = "^0.6.0"
+
+[tool.poetry.extras]
+attrs = ["attrs"]
+
+[tool.poetry.scripts]
+tests = 'poetry_scripts:run_tests'
+format = 'poetry_scripts:run_format'
+lint = 'poetry_scripts:run_lint'
+type-check = 'poetry_scripts:run_type_check'
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pylint.messages_control]
+disable = [
+    "missing-final-newline",
+    "missing-module-docstring",
+    "missing-function-docstring",
+    "missing-class-docstring",
+    "too-few-public-methods",
+    "too-many-branches",
+    "too-many-return-statements",
+    "too-many-statements",
+    "too-many-locals",
+    "too-many-lines",
+    "too-many-arguments",
+    "too-many-instance-attributes",
+    "too-many-boolean-expressions",
+    "too-many-positional-arguments",
+    "protected-access",
+    "duplicate-code",
+    "too-many-nested-blocks",
+    "line-too-long",
+    "import-outside-toplevel",
+    "invalid-name"
+]
+
+[tool.black]
+line-length = 180
+
+[tool.pyright]
+include = ["src"]
+pythonVersion = "3.11"
+pythonPlatform = "Linux"
+reportAttributeAccessIssue = "none"

kognitos_bdk_api-1.12.4/src/kognitos/bdk/__version__.py

@@ -0,0 +1 @@
+__version__ = "3.0.0"

kognitos_bdk_api-1.12.4/src/kognitos/bdk/api/__init__.py

@@ -0,0 +1,7 @@
+from .errors import NotFoundError, TypeMismatchError
+from .filter import (FilterBinaryExpression, FilterBinaryOperator,
+                     FilterExpression, FilterExpressionVisitor,
+                     FilterUnaryExpression, FilterUnaryOperator,
+                     NounPhrasesExpression, ValueExpression)
+from .noun_phrase import NounPhrase
+from .table import Table

kognitos_bdk_api-1.12.4/src/kognitos/bdk/api/errors.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from ..reflection.types import ConceptType
+
+
+class TypeMismatchError(Exception):
+    where: str
+    expected: Optional[ConceptType]
+
+    def __init__(self, where: str, expected: ConceptType):
+        self.where = where
+        self.expected = expected
+        super().__init__(f"type mismatch on {where} expected {expected}")
+
+
+class NotFoundError(Exception):
+    message: str
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(message)

kognitos_bdk_api-1.12.4/src/kognitos/bdk/api/filter.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from datetime import date, datetime, time
+from enum import Enum
+from typing import Generic, List, TypeVar
+
+from kognitos.bdk.api.noun_phrase import NounPhrase
+
+T = TypeVar("T")
+
+
+class FilterExpressionVisitor(ABC, Generic[T]):
+    @abstractmethod
+    def visit_binary_expression(self, expression: FilterBinaryExpression) -> T:
+        pass
+
+    @abstractmethod
+    def visit_unary_expression(self, expression: FilterUnaryExpression) -> T:
+        pass
+
+    @abstractmethod
+    def visit_value(self, expression: ValueExpression) -> T:
+        pass
+
+    @abstractmethod
+    def visit_noun_phrases(self, expression: NounPhrasesExpression) -> T:
+        pass
+
+
+class FilterExpression(ABC):
+    @abstractmethod
+    def accept(self, visitor: FilterExpressionVisitor[T]) -> T:
+        pass
+
+
+class FilterBinaryOperator(Enum):
+    AND = 0
+    OR = 1
+    EQUALS = 2
+    NOT_EQUALS = 3
+    IN = 4
+    HAS = 5
+    LESS_THAN = 6
+    GREATER_THAN = 7
+    LESS_THAN_OR_EQUAL = 8
+    GREATER_THAN_OR_EQUAL = 9
+
+
+class FilterUnaryOperator(Enum):
+    NOT = 0
+
+
+class FilterBinaryExpression(FilterExpression):
+    def __init__(self, left: FilterExpression, operator: FilterBinaryOperator, right: FilterExpression):
+        self.operator = operator
+        self.left = left
+        self.right = right
+
+    def accept(self, visitor: FilterExpressionVisitor[T]) -> T:
+        return visitor.visit_binary_expression(self)
+
+
+class FilterUnaryExpression(FilterExpression):
+    def __init__(self, operator: FilterUnaryOperator, inner: FilterExpression):
+        self.operator = operator
+        self.inner = inner
+
+    def accept(self, visitor: FilterExpressionVisitor[T]) -> T:
+        return visitor.visit_unary_expression(self)
+
+
+class ValueExpression(FilterExpression):
+    def __init__(self, value: str | int | bool | float | date | datetime | time):
+        self.value = value
+
+    def accept(self, visitor: FilterExpressionVisitor[T]) -> T:
+        return visitor.visit_value(self)
+
+
+class NounPhrasesExpression(FilterExpression):
+    def __init__(self, noun_phrases: List[NounPhrase]):
+        self.noun_phrases = noun_phrases
+
+    def accept(self, visitor: FilterExpressionVisitor[T]) -> T:
+        return visitor.visit_noun_phrases(self)

kognitos_bdk_api-1.12.4/src/kognitos/bdk/api/noun_phrase.py

@@ -0,0 +1,99 @@
+import re
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+
+@dataclass
+class NounPhrase:
+    """Represents a noun phrase.
+
+    Args:
+        head (str): The head of the noun phrase.
+        modifiers (List[str], optional): The modifiers of the noun phrase. Defaults to None.
+
+    Methods:
+        __str__(): Returns a string representation of the noun phrase.
+        to_string(): Returns a string representation of the noun phrase.
+
+    Examples:
+        # Create a noun phrase with the head "cat"
+        >>> np = NounPhrase("cat")
+        >>> print(np)
+        cat
+
+        # Create a noun phrase with the head "dog" and modifiers ["big", "white"]
+        >>> np = NounPhrase("dog", ["big", "white"])
+        >>> print(np)
+        big white dog
+
+    """
+
+    head: str
+    modifiers: Optional[List[str]] = None
+
+    def __eq__(self, other):
+        if self.head != other.head:
+            return False
+
+        self_modifiers = self.modifiers if self.modifiers else []
+        other_modifiers = other.modifiers if other.modifiers else []
+
+        return self_modifiers == other_modifiers
+
+    def __str__(self):
+        return self.to_string()
+
+    def to_string(self):
+        return " ".join((self.modifiers if self.modifiers else []) + [self.head])
+
+    @classmethod
+    def from_snake_case(cls, snake_str: str) -> "NounPhrase":
+        # replace underscores with spaces
+        words = snake_str.replace("_", " ")
+        return NounPhrase(head=words, modifiers=[])
+
+    @classmethod
+    def from_pascal_case(cls, pascal_str: str) -> "NounPhrase":
+        # remove existing spaces
+        pascal_str = pascal_str.replace(" ", "")
+        # insert space before each capital letter (except the first one)
+        words = re.sub(r"(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", " ", pascal_str).lower()
+        return NounPhrase(head=words, modifiers=[])
+
+    @classmethod
+    def from_head(cls, head: str) -> "NounPhrase":
+        return NounPhrase(head=head, modifiers=[])
+
+    @classmethod
+    def from_str(cls, string: str) -> "NounPhrase":
+        return NounPhrase.from_word_list(string.split(" "))
+
+    @classmethod
+    def from_word_list(cls, word_list: List[str]) -> "NounPhrase":
+        return NounPhrase(head=word_list[-1], modifiers=word_list[0:-1])
+
+    @classmethod
+    def from_tuple(cls, noun_phrase_tuple: Tuple[str, Optional[List[str]]]) -> "NounPhrase":
+        return NounPhrase(noun_phrase_tuple[0], noun_phrase_tuple[1])
+
+    def to_camel_case(self) -> str:
+        snake_str = self.to_snake_case()
+        components = snake_str.split("_")
+        return components[0] + "".join(x.title() for x in components[1:])
+
+    def to_snake_case(self) -> str:
+        text = self.to_string()
+        return text.lower().replace(" ", "_")
+
+    def to_kebab_case(self) -> str:
+        snake_str = self.to_snake_case()
+        return snake_str.replace("_", "-")
+
+    def to_field_names(self) -> List[str]:
+        snake_case = self.to_snake_case()
+        camel_case = self.to_camel_case()
+        kebab_case = self.to_kebab_case()
+        return [snake_case, camel_case, kebab_case]
+
+    def __hash__(self):
+        return hash((self.head, tuple(self.modifiers) if self.modifiers else ()))

kognitos_bdk_api-1.12.4/src/kognitos/bdk/api/table.py

@@ -0,0 +1,2 @@
+class Table:
+    pass

kognitos_bdk_api-1.12.4/src/kognitos/bdk/blueprints/__init__.py

@@ -0,0 +1,5 @@
+"""Home for all Blueprint classes."""
+
+from .file_storage_blueprint import FileStorageBlueprint
+
+__all__ = ["FileStorageBlueprint"]

kognitos_bdk_api-1.12.4/src/kognitos/bdk/blueprints/file_storage_blueprint.py

@@ -0,0 +1,146 @@
+# type: ignore [reportReturnType]
+from dataclasses import dataclass
+from typing import IO, List, Optional, Union
+
+from kognitos.bdk.api import FilterExpression
+from kognitos.bdk.decorators import blueprint, blueprint_procedure, concept
+
+
+@dataclass
+@concept(is_a="file reference")
+class FileReference:
+    """
+    Contains all information required to identify a file within a storage system
+    """
+
+
+@dataclass
+@concept(is_a="folder reference")
+class FolderReference:
+    """
+    Contains all information required to identify a folder within a storage system
+    """
+
+
+@blueprint
+class FileStorageBlueprint:
+    """
+    A blueprint for files.
+    """
+
+    @blueprint_procedure("to get a (root folder)")
+    def get_root_folder(self) -> FolderReference:
+        """
+        Gets a reference to the root folder.
+
+        Returns:
+            a folder reference
+        """
+
+    @blueprint_procedure("to get a (folder) at a path")
+    def get_folder(self, path: str) -> FolderReference:
+        """
+        Gets a reference to a folder.
+
+        Input Concepts:
+            the path: The path to the folder
+
+        Returns:
+            a folder reference
+        """
+
+    @blueprint_procedure("to get some (folder's items)")
+    def list_items(self, folder: FolderReference, filter_expression: Optional[FilterExpression] = None) -> List[Union[FileReference, FolderReference]]:
+        """
+        Lists items from a folder reference
+
+        Input Concepts:
+            the folder: The folder reference from which to list the items
+            the filter expression: A filter expression to filter the items in the folder
+
+        Returns:
+            a list of Items (file or folder) containing the items in the folder
+        """
+
+    @blueprint_procedure("to rename an item to a name")
+    def rename_item(self, item: Union[FileReference, FolderReference], name: str, conflict_behavior: Optional[str] = "fail") -> None:
+        """
+        Rename an item (file or folder) to a given name
+
+        Input Concepts:
+            the item: The item (file or folder) to rename
+            the name: The new name of the item
+            the conflict behavior: The behavior to use on conflict scenarios. It should be one of the following values: ('fail', 'replace', 'rename')
+        """
+
+    @blueprint_procedure("to delete an item")
+    def delete_an_item(self, item: Union[FileReference, FolderReference]) -> None:
+        """
+        Delete an item (file or folder)
+
+        Input Concepts:
+            the item: The item (file or folder) to delete
+        """
+
+    @blueprint_procedure("to download a file")
+    def download_item(self, file: FileReference) -> IO:
+        """
+        Download a file
+
+        Input Concepts:
+            the file: The file reference to the file to download
+
+        Returns:
+            the file as an IO object
+        """
+
+    @blueprint_procedure("to create a (folder) in another folder")
+    def create_folder(self, another_folder: FolderReference, folder_name: str, conflict_behavior: Optional[str] = "fail") -> FolderReference:
+        """
+        Create a (folder) in another folder
+
+        Input Concepts:
+            the another folder: The folder to create the (folder) in
+            the folder name: The name of the (folder) to create
+            the conflict behavior: The behavior to use on conflict scenarios. It should be one of the following values: ('fail', 'replace', 'rename')
+
+        Returns:
+            a folder reference to the created folder
+        """
+
+    @blueprint_procedure("to upload a (file) to a folder")
+    def upload_file_to_folder(self, file: IO, folder: FolderReference, file_name: str, conflict_behavior: Optional[str] = "fail") -> FileReference:
+        """
+        Upload a file to a folder
+
+        Input Concepts:
+            the file: The file to upload
+            the folder: The folder to upload the file to
+            the file name: The name of the file to upload
+            the conflict behavior: The behavior to use on conflict scenarios. It should be one of the following values: ('fail', 'replace', 'rename')
+
+        Returns:
+            a file reference to the uploaded file
+        """
+
+    @blueprint_procedure("to copy an item to a folder")
+    def copy_item(self, item: Union[FileReference, FolderReference], folder: FolderReference, conflict_behavior: Optional[str] = "fail") -> None:
+        """
+        Copy an item to a folder
+
+        Input Concepts:
+            the item: The item (file or folder) to copy
+            the folder: The folder to copy the item to
+            the conflict behavior: The behavior to use on conflict scenarios. It should be one of the following values: ('fail', 'replace', 'rename')
+        """
+
+    @blueprint_procedure("to move an item to a folder")
+    def move_item(self, item: Union[FileReference, FolderReference], folder: FolderReference, conflict_behavior: Optional[str] = "fail") -> None:
+        """
+        Move an item to a folder
+
+        Input Concepts:
+            the item: The item (file or folder) to move
+            the folder: The folder to move the item to
+            the conflict behavior: The behavior to use on conflict scenarios. It should be one of the following values: ('fail', 'replace', 'rename')
+        """

kognitos_bdk_api-1.12.4/src/kognitos/bdk/decorators/__init__.py

@@ -0,0 +1,8 @@
+from .blueprint_decorator import blueprint, blueprint_procedure
+from .book_decorator import book
+from .concept_decorator import concept
+from .config_decorator import config
+from .connect_decorator import connect
+from .oauth_decorator import OAuthFlow, OAuthProvider, oauth
+from .oauthtoken_decorator import oauthtoken
+from .procedure_decorator import procedure

kognitos_bdk_api-1.12.4/src/kognitos/bdk/decorators/blueprint_decorator.py

@@ -0,0 +1,32 @@
+import inspect
+from functools import wraps
+from typing import Optional
+
+from ..reflection import BookProcedureSignature
+
+
+def blueprint(*args):
+    cls = Optional[type]
+
+    # NOTE: We only care about the first argument, the rest of args and all kwargs are ignored.
+    if len(args) >= 1 and inspect.isclass(args[0]):
+        cls = args[0]
+
+        def decorator(cls):
+            if not hasattr(cls.__dict__, "__is_blueprint"):
+                cls.__is_blueprint = True
+            return cls
+
+        return decorator(cls)
+
+    raise ValueError("@blueprint decorator must be applied to a class.")
+
+
+def blueprint_procedure(name: str):
+    # This is here to verify that the english is valid
+    BookProcedureSignature.from_english(name)
+
+    def wrapper(fn):
+        return wraps(fn)(fn)
+
+    return wrapper