dkg 0.1.0b1__py3-none-any.whl

dkg/data/interfaces/WhitelistStorage.json

@@ -0,0 +1,124 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "hubAddress",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "addr",
+        "type": "address"
+      }
+    ],
+    "name": "blacklistAddress",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "disableWhitelist",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "enableWhitelist",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "hub",
+    "outputs": [
+      {
+        "internalType": "contract Hub",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "name",
+    "outputs": [
+      {
+        "internalType": "string",
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "pure",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "version",
+    "outputs": [
+      {
+        "internalType": "string",
+        "name": "",
+        "type": "string"
+      }
+    ],
+    "stateMutability": "pure",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "addr",
+        "type": "address"
+      }
+    ],
+    "name": "whitelistAddress",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "whitelisted",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "whitelistingEnabled",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

dkg/dataclasses.py

@@ -0,0 +1,45 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+from enum import Enum
+
+import pandas as pd
+
+
+class BlockchainResponseDict(dict):
+    pass
+
+
+class HTTPRequestMethod(Enum):
+    GET = 1
+    POST = 2
+
+
+class NodeResponseDict(dict):
+    def to_dataframe(self) -> pd.DataFrame:
+        return pd.DataFrame(self)
+
+
+class KnowledgeAssetEnumStates(Enum):
+    LATEST = "LATEST"
+    LATEST_FINALIZED = "LATEST_FINALIZED"
+
+
+class KnowledgeAssetContentVisibility(Enum):
+    ALL = "ALL"
+    PUBLIC = "PUBLIC"
+    PRIVATE = "PRIVATE"

dkg/exceptions.py

@@ -0,0 +1,161 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+class DKGException(Exception):
+    """
+    Exception mixin inherited by all exceptions of dkg.py
+    This allows::
+        try:
+            some_call()
+        except DKGException:
+            # deal with dkg exception
+        except:
+            # deal with other exceptions
+    """
+
+
+class NetworkNotSupported(DKGException):
+    """
+    Raised when blockchain provider is initialized for unsupported network.
+    """
+
+    pass
+
+
+class InvalidStateOption(DKGException):
+    """
+    Raised when invalid state option given to the get operation.
+    """
+
+    pass
+
+
+class MissingKnowledgeAssetState(DKGException):
+    """
+    Raised when search for the Knowledge Asset state on the network has failed.
+    """
+
+    pass
+
+
+class ValidationError(DKGException):
+    """
+    Raised when something does not pass a validation check.
+    """
+
+    pass
+
+
+class InvalidRequest(DKGException):
+    """
+    Raised by a manager to signal that blockchain/node request method
+    doesn't exist.
+    """
+
+    pass
+
+
+class HTTPRequestMethodNotSupported(DKGException):
+    """
+    Raised if used HTTP method isn't supported
+    """
+
+    pass
+
+
+class NodeRequestError(DKGException):
+    """
+    Raised by Node HTTP Provider if error occured during request.
+    """
+
+    pass
+
+
+class OperationNotFinished(DKGException):
+    """
+    Raised when requested operation result isn't ready.
+    """
+
+    pass
+
+
+class OperationFailed(DKGException):
+    """
+    Raised when requested operation status is failed.
+    """
+
+    pass
+
+
+class AccountMissing(DKGException):
+    """
+    Raised when trying to perform state-changing blockchain transaction without account
+    specified.
+    """
+
+    pass
+
+
+class InvalidDataset(DKGException):
+    """
+    Raised when dataset URDNA2015 normalization doesn't result in any quads.
+    """
+
+    pass
+
+
+class DatasetInputFormatNotSupported(DKGException):
+    """
+    Raised when trying to normalize RDF dataset with not supported input format.
+    """
+
+    pass
+
+
+class DatasetOutputFormatNotSupported(DKGException):
+    """
+    Raised when trying to convert RDF dataset to not supported output format.
+    """
+
+    pass
+
+
+class InvalidKnowledgeAsset(DKGException):
+    """
+    Raised when root of the Merkle Tree built from N-Quads isn't the same as the
+    assertionId.
+    """
+
+    pass
+
+
+class InvalidTokenAmount(DKGException):
+    """
+    Raised when token amount for operation isn't specified and suggested amount is less
+    or equal to what is already present in the contract.
+    """
+
+    pass
+
+
+class LeafNotInTree(DKGException):
+    """
+    Raised when proof/verification requested for the leaf that is not the part of the
+    Merkle Tree.
+    """
+
+    pass

dkg/graph.py

@@ -0,0 +1,63 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+from rdflib.plugins.sparql.parser import parseQuery
+
+from dkg.dataclasses import NodeResponseDict
+from dkg.exceptions import OperationNotFinished
+from dkg.manager import DefaultRequestManager
+from dkg.method import Method
+from dkg.module import Module
+from dkg.types import NQuads
+from dkg.utils.decorators import retry
+from dkg.utils.node_request import NodeRequest, validate_operation_status
+
+
+class Graph(Module):
+    def __init__(self, manager: DefaultRequestManager):
+        self.manager = manager
+
+    _query = Method(NodeRequest.query)
+    _get_operation_result = Method(NodeRequest.get_operation_result)
+
+    def query(
+        self,
+        query: str,
+        repository: str,
+    ) -> NQuads:
+        parsed_query = parseQuery(query)
+        query_type = parsed_query[1].name.replace("Query", "").upper()
+
+        operation_id: NodeResponseDict = self._query(query, query_type, repository)[
+            "operationId"
+        ]
+        operation_result = self.get_operation_result(operation_id, "query")
+
+        return operation_result["data"]
+
+    @retry(catch=OperationNotFinished, max_retries=5, base_delay=1, backoff=2)
+    def get_operation_result(
+        self, operation_id: str, operation: str
+    ) -> NodeResponseDict:
+        operation_result = self._get_operation_result(
+            operation_id=operation_id,
+            operation=operation,
+        )
+
+        validate_operation_status(operation_result)
+
+        return operation_result

dkg/main.py

@@ -0,0 +1,74 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+from functools import wraps
+
+from dkg.asset import ContentAsset
+from dkg.graph import Graph
+from dkg.manager import DefaultRequestManager
+from dkg.module import Module
+from dkg.node import Node
+from dkg.providers import BlockchainProvider, NodeHTTPProvider
+from dkg.types import UAL, Address, ChecksumAddress
+from dkg.utils.ual import format_ual, parse_ual
+
+
+class DKG(Module):
+    asset: ContentAsset
+    node: Node
+    graph: Graph
+
+    @staticmethod
+    @wraps(format_ual)
+    def format_ual(
+        blockchain: str, contract_address: Address | ChecksumAddress, token_id: int
+    ) -> UAL:
+        return format_ual(blockchain, contract_address, token_id)
+
+    @staticmethod
+    @wraps(parse_ual)
+    def parse_ual(ual: UAL) -> dict[str, str | Address | int]:
+        return parse_ual(ual)
+
+    def __init__(
+        self,
+        node_provider: NodeHTTPProvider,
+        blockchain_provider: BlockchainProvider,
+    ):
+        self.manager = DefaultRequestManager(node_provider, blockchain_provider)
+        modules = {
+            "asset": ContentAsset(self.manager),
+            "node": Node(self.manager),
+            "graph": Graph(self.manager),
+        }
+        self._attach_modules(modules)
+
+    @property
+    def node_provider(self) -> NodeHTTPProvider:
+        return self.manager.node_provider
+
+    @node_provider.setter
+    def node_provider(self, node_provider: NodeHTTPProvider) -> None:
+        self.manager.node_provider = node_provider
+
+    @property
+    def blockchain_provider(self) -> BlockchainProvider:
+        return self.manager.blockchain_provider
+
+    @blockchain_provider.setter
+    def blockchain_provider(self, blockchain_provider: BlockchainProvider) -> None:
+        self.manager.blockchain_provider = blockchain_provider

dkg/manager.py

@@ -0,0 +1,64 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+from typing import Any, Type
+
+from dkg.dataclasses import BlockchainResponseDict, NodeResponseDict
+from dkg.exceptions import InvalidRequest
+from dkg.providers import BlockchainProvider, NodeHTTPProvider
+from dkg.utils.blockchain_request import ContractInteraction, JSONRPCRequest
+from dkg.utils.node_request import NodeCall
+
+
+class DefaultRequestManager:
+    def __init__(
+        self, node_provider: NodeHTTPProvider, blockchain_provider: BlockchainProvider
+    ):
+        self._node_provider = node_provider
+        self._blockchain_provider = blockchain_provider
+
+    @property
+    def node_provider(self) -> NodeHTTPProvider:
+        return self._node_provider
+
+    @node_provider.setter
+    def node_provider(self, node_provider: NodeHTTPProvider) -> None:
+        self._node_provider = node_provider
+
+    @property
+    def blockchain_provider(self) -> BlockchainProvider:
+        return self._blockchain_provider
+
+    @blockchain_provider.setter
+    def blockchain_provider(self, blockchain_provider: BlockchainProvider) -> None:
+        self._blockchain_provider = blockchain_provider
+
+    def blocking_request(
+        self,
+        request_type: Type[JSONRPCRequest | ContractInteraction | NodeCall],
+        request_params: dict[str, Any],
+    ) -> BlockchainResponseDict | NodeResponseDict:
+        if issubclass(request_type, JSONRPCRequest):
+            return self.blockchain_provider.make_json_rpc_request(**request_params)
+        elif issubclass(request_type, ContractInteraction):
+            return self.blockchain_provider.call_function(**request_params)
+        elif issubclass(request_type, NodeCall):
+            return self.node_provider.make_request(**request_params)
+        else:
+            raise InvalidRequest(
+                "Invalid Request. Manager can only process Blockchain/Node requests."
+            )

dkg/method.py

@@ -0,0 +1,131 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+import itertools
+import re
+from typing import TYPE_CHECKING, Any, Generic, Type
+
+from dkg.exceptions import ValidationError
+from dkg.types import TFunc
+from dkg.utils.blockchain_request import (ContractInteraction,
+                                          ContractTransaction, JSONRPCRequest)
+from dkg.utils.node_request import NodeCall
+from dkg.utils.string_transformations import snake_to_camel
+
+if TYPE_CHECKING:
+    from dkg.module import Module
+
+
+class Method(Generic[TFunc]):
+    def __init__(self, action: JSONRPCRequest | ContractInteraction | NodeCall):
+        self.action = action
+
+    def __get__(
+        self, obj: "Module | None" = None, _: Type["Module"] | None = None
+    ) -> TFunc:
+        if obj is None:
+            raise TypeError(
+                "Direct calls to methods are not supported. "
+                "Methods must be called from a module instance, "
+                "usually attached to a dkg instance."
+            )
+        return obj.retrieve_caller_fn(self)
+
+    def process_args(self, *args: Any, **kwargs: Any):
+        match self.action:
+            case JSONRPCRequest():
+                return {"args": self._validate_and_map(self.action.args, args, kwargs)}
+            case ContractInteraction():
+                return {
+                    "args": self._validate_and_map(self.action.args, args, kwargs),
+                    "state_changing": isinstance(self.action, ContractTransaction),
+                }
+            case NodeCall():
+                path_placeholders = re.findall(r"\{([^{}]+)?\}", self.action.path)
+
+                args_in_path = 0
+                path_args = []
+                path_kwargs = {}
+                if len(path_placeholders) > 0:
+                    for placeholder in path_placeholders:
+                        if (placeholder != "") and (placeholder in kwargs.keys()):
+                            path_kwargs[placeholder] = kwargs.pop(placeholder)
+                        else:
+                            if len(args) <= args_in_path:
+                                raise ValidationError(
+                                    "Number of given arguments can't be smaller than "
+                                    "number of path placeholders"
+                                )
+
+                            if placeholder == "":
+                                path_args.append(args[args_in_path])
+                            else:
+                                path_kwargs[placeholder] = args[args_in_path]
+
+                            args_in_path += 1
+
+                return {
+                    "path": self.action.path.format(*path_args, **path_kwargs),
+                    "params": self._validate_and_map(
+                        self.action.params, args[args_in_path:], kwargs
+                    )
+                    if self.action.params
+                    else {},
+                    "data": self._validate_and_map(
+                        self.action.data, args[args_in_path:], kwargs
+                    )
+                    if self.action.data
+                    else {},
+                }
+
+            case _:
+                return {}
+
+    def _validate_and_map(
+        self,
+        required_args: dict[str, Type] | Type,
+        args: list[Any],
+        kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
+        if not isinstance(required_args, dict):
+            if (len(args) + len(kwargs)) != 1:
+                raise ValidationError("Exactly one argument must be provided.")
+
+            if len(args) == 1:
+                return args[0]
+            else:
+                return list(kwargs.values())[0]
+
+        if len(args) > len(required_args):
+            raise ValidationError(
+                "Number of positional arguments can't be bigger than "
+                "number of required arguments"
+            )
+
+        args_mapped = dict(zip(itertools.islice(required_args.keys(), len(args)), args))
+        camel_kwargs = {snake_to_camel(key): value for key, value in kwargs.items()}
+
+        processed_args = {}
+        processed_args.update(args_mapped)
+        processed_args.update(camel_kwargs)
+
+        if any(missing_params := (arg not in processed_args for arg in required_args)):
+            raise ValidationError(
+                f"Missing required arg(s): {', '.join(missing_params)}"
+            )
+
+        return processed_args