dkg 1.1.1__py3-none-any.whl → 8.0.0__py3-none-any.whl

dkg/services/input_service.py

@@ -0,0 +1,183 @@
+from dkg.constants import (
+    DefaultParameters,
+    ZERO_ADDRESS,
+    DEFAULT_PROXIMITY_SCORE_FUNCTIONS_PAIR_IDS,
+)
+
+
+class InputService:
+    def __init__(self, manager, config):
+        self.manager = manager
+        self.config = config
+
+    def get_asset_get_arguments(self, options):
+        return {
+            "max_number_of_retries": self.get_max_number_of_retries(options),
+            "frequency": self.get_frequency(options),
+            "state": self.get_state(options),
+            "include_metadata": self.get_include_metadata(options),
+            "content_type": self.get_content_type(options),
+            "validate": self.get_validate(options),
+            "output_format": self.get_output_format(options),
+            "hash_function_id": self.get_hash_function_id(options),
+            "paranet_ual": self.get_paranet_ual(options),
+            "subject_ual": self.get_subject_ual(options),
+        }
+
+    def get_asset_create_arguments(self, options):
+        return {
+            "max_number_of_retries": self.get_max_number_of_retries(options),
+            "frequency": self.get_frequency(options),
+            "epochs_num": self.get_epochs_num(options),
+            "hash_function_id": self.get_hash_function_id(options),
+            "score_function_id": self.get_score_function_id(options),
+            "immutable": self.get_immutable(options),
+            "token_amount": self.get_token_amount(options),
+            "payer": self.get_payer(options),
+            "minimum_number_of_finalization_confirmations": self.get_minimum_number_of_finalization_confirmations(
+                options
+            ),
+            "minimum_number_of_node_replications": self.get_minimum_number_of_node_replications(
+                options
+            ),
+        }
+
+    def get_query_arguments(self, options):
+        return {
+            "max_number_of_retries": self.get_max_number_of_retries(options),
+            "frequency": self.get_frequency(options),
+            "paranet_ual": self.get_paranet_ual(options),
+            "repository": self.get_repository(options),
+        }
+
+    def get_publish_finality_arguments(self, options):
+        return {
+            "max_number_of_retries": self.get_max_number_of_retries(options),
+            "frequency": self.get_frequency(options),
+            "minimum_number_of_finalization_confirmations": self.get_minimum_number_of_finalization_confirmations(
+                options
+            ),
+        }
+
+    def get_max_number_of_retries(self, options):
+        return (
+            options.get("max_number_of_retries")
+            or self.config.get("max_number_of_retries")
+            or DefaultParameters.MAX_NUMBER_OF_RETRIES.value
+        )
+
+    def get_frequency(self, options):
+        return (
+            options.get("frequency")
+            or self.config.get("frequency")
+            or DefaultParameters.FREQUENCY.value
+        )
+
+    def get_state(self, options):
+        return (
+            options.get("state")
+            or self.config.get("state")
+            or DefaultParameters.STATE.value
+        )
+
+    def get_include_metadata(self, options):
+        return (
+            options.get("include_metadata")
+            or self.config.get("include_metadata")
+            or DefaultParameters.INCLUDE_METADATA.value
+        )
+
+    def get_content_type(self, options):
+        return (
+            options.get("content_type")
+            or self.config.get("content_type")
+            or DefaultParameters.CONTENT_TYPE.value
+        )
+
+    def get_validate(self, options):
+        return (
+            options.get("validate")
+            or self.config.get("validate")
+            or DefaultParameters.VALIDATE.value
+        )
+
+    def get_output_format(self, options):
+        return (
+            options.get("output_format")
+            or self.config.get("output_format")
+            or DefaultParameters.OUTPUT_FORMAT.value
+        )
+
+    def get_hash_function_id(self, options):
+        return (
+            options.get("hash_function_id")
+            or self.config.get("hash_function_id")
+            or DefaultParameters.HASH_FUNCTION_ID.value
+        )
+
+    def get_paranet_ual(self, options):
+        return (
+            options.get("paranet_ual")
+            or self.config.get("paranet_ual")
+            or DefaultParameters.PARANET_UAL.value
+        )
+
+    def get_subject_ual(self, options):
+        return (
+            options.get("subject_ual")
+            or self.config.get("subject_ual")
+            or DefaultParameters.GET_SUBJECT_UAL.value
+        )
+
+    def get_epochs_num(self, options):
+        return options.get("epochs_num") or self.config.get("epochs_num") or None
+
+    def get_immutable(self, options):
+        return (
+            options.get("immutable")
+            or self.config.get("immutable")
+            or DefaultParameters.IMMUTABLE.value
+        )
+
+    def get_token_amount(self, options):
+        return options.get("token_amount") or self.config.get("token_amount") or None
+
+    def get_payer(self, options):
+        return options.get("payer") or self.config.get("payer") or ZERO_ADDRESS
+
+    def get_minimum_number_of_finalization_confirmations(self, options):
+        return (
+            options.get("minimum_number_of_finalization_confirmations")
+            or self.config.get("minimum_number_of_finalization_confirmations")
+            or DefaultParameters.MIN_NUMBER_OF_FINALIZATION_CONFIRMATION.value
+            or None
+        )
+
+    def get_minimum_number_of_node_replications(self, options):
+        return (
+            options.get("minimum_number_of_node_replications")
+            or self.config.get("minimum_number_of_node_replications")
+            or None
+        )
+
+    def get_score_function_id(self, options):
+        environment = (
+            options.get("environment")
+            or self.config.get("environment")
+            or self.manager.blockchain_provider.environment
+            or DefaultParameters.ENVIRONMENT.value
+        )
+        blockchain_name = (
+            options.get("blockchain")
+            or self.config.get("blockchain")
+            or self.manager.blockchain_provider.blockchain_id
+        )
+
+        return DEFAULT_PROXIMITY_SCORE_FUNCTIONS_PAIR_IDS[environment][blockchain_name]
+
+    def get_repository(self, options):
+        return (
+            options.get("repository")
+            or self.config.get("repository")
+            or DefaultParameters.REPOSITORY.value
+        )

dkg/services/node_service.py

@@ -0,0 +1,164 @@
+from dkg.manager import DefaultRequestManager
+from dkg.method import Method
+from dkg.module import Module
+import time
+from dkg.utils.decorators import retry
+from dkg.exceptions import (
+    OperationNotFinished,
+)
+from dkg.utils.node_request import (
+    NodeRequest,
+    validate_operation_status,
+)
+
+
+class NodeService(Module):
+    def __init__(self, manager: DefaultRequestManager):
+        self.manager = manager
+
+    _get_operation_result = Method(NodeRequest.get_operation_result)
+    _finality_status = Method(NodeRequest.finality_status)
+    _ask = Method(NodeRequest.ask)
+    _publish = Method(NodeRequest.publish)
+    _get = Method(NodeRequest.get)
+    _query = Method(NodeRequest.query)
+
+    def get_operation_result(
+        self, operation_id: str, operation: str, max_retries: int, frequency: int
+    ):
+        @retry(
+            catch=OperationNotFinished,
+            max_retries=max_retries,
+            base_delay=frequency,
+            backoff=1,
+        )
+        def retry_get_operation_result():
+            operation_result = self._get_operation_result(
+                operation_id=operation_id,
+                operation=operation,
+            )
+            validate_operation_status(operation_result)
+
+            return operation_result
+
+        return retry_get_operation_result()
+
+    def finality_status(
+        self,
+        ual: str,
+        required_confirmations: int,
+        max_number_of_retries: int,
+        frequency: int,
+    ):
+        retries = 0
+        finality = 0
+
+        while finality < required_confirmations and retries <= max_number_of_retries:
+            if retries > max_number_of_retries:
+                raise Exception(
+                    f"Unable to achieve required confirmations. "
+                    f"Max number of retries ({max_number_of_retries}) reached."
+                )
+
+            if retries > 0:
+                time.sleep(frequency)
+
+            retries += 1
+
+            try:
+                try:
+                    response = self._finality_status(ual=ual)
+                except Exception as e:
+                    response = None
+                    print(f"failed: {e}")
+
+                if response is not None:
+                    finality = response.get("finality", 0)
+                    if finality >= required_confirmations:
+                        break
+
+            except Exception:
+                finality = 0
+
+        return finality
+
+    def ask(self, ual, required_confirmations, max_number_of_retries, frequency):
+        ask = 0
+        retries = 0
+
+        while ask < required_confirmations and retries < max_number_of_retries:
+            if retries > max_number_of_retries:
+                raise Exception(
+                    f"Unable to achieve required confirmations. "
+                    f"Max number of retries ({max_number_of_retries}) reached."
+                )
+
+            if retries > 0:
+                time.sleep(frequency)
+
+            retries += 1
+
+            try:
+                try:
+                    response = self._ask(
+                        ual=ual, minimumNumberOfNodeReplications=required_confirmations
+                    )
+                except Exception as e:
+                    response = None
+                    print(f"failed: {e}")
+
+                if response is not None:
+                    number_of_confirmations = response.json().get(
+                        "numberOfConfirmations", 0
+                    )
+                    if number_of_confirmations >= required_confirmations:
+                        ask = number_of_confirmations
+
+            except Exception as e:
+                ask = 0
+                print(f"Retry {retries + 1}/{max_number_of_retries} failed: {e}")
+
+            return ask
+
+    def publish(
+        self,
+        dataset_root,
+        dataset,
+        blockchain_id,
+        hash_function_id,
+        minimum_number_of_node_replications,
+    ):
+        return self._publish(
+            dataset_root,
+            dataset,
+            blockchain_id,
+            hash_function_id,
+            minimum_number_of_node_replications,
+        )
+
+    def get(
+        self,
+        ual_with_state,
+        content_type,
+        include_metadata,
+        hash_function_id,
+        paranet_ual,
+        subject_ual,
+    ):
+        return self._get(
+            ual_with_state,
+            content_type,
+            include_metadata,
+            hash_function_id,
+            paranet_ual,
+            subject_ual,
+        )
+
+    def query(
+        self,
+        query,
+        query_type,
+        repository,
+        paranet_ual,
+    ):
+        return self._query(query, query_type, repository, paranet_ual)

dkg/types/__init__.py

@@ -1,6 +1,18 @@
-from .general import AutoStrEnum, AutoStrEnumCapitalize, AutoStrEnumUpperCase # NOQA: F401
-from .blockchain import (ABI, ABIElement, ABIError, ABIEvent,  # NOQA: F401
-                         ABIFunction, ABIParameter, AgreementData, Environment)
+from .general import (
+    AutoStrEnum,  # NOQA: F401
+    AutoStrEnumCapitalize,  # NOQA: F401
+    AutoStrEnumUpperCase,  # NOQA: F401
+)
+from .blockchain import (
+    ABI,  # NOQA: F401
+    ABIElement,  # NOQA: F401
+    ABIError,  # NOQA: F401
+    ABIEvent,  # NOQA: F401
+    ABIFunction,  # NOQA: F401
+    ABIParameter,  # NOQA: F401
+    AgreementData,  # NOQA: F401
+    Environment,  # NOQA: F401
+)
 from .dkg_node import UAL  # NOQA: F401
 from .encoding import BytesLike, DataHexStr, HexStr  # NOQA: F401
 from .evm import Address, ChecksumAddress, Wei  # NOQA: F401

dkg/types/general.py

@@ -17,28 +17,35 @@
 
 from enum import Enum
 
+
 class AutoStrEnum(str, Enum):
     @staticmethod
-    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list
+    ) -> str:
         return name.lower()
-    
+
     def __str__(self):
         return str(self.value)
-    
+
 
 class AutoStrEnumCapitalize(str, Enum):
     @staticmethod
-    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list
+    ) -> str:
         return name.capitalize()
-    
+
     def __str__(self):
         return str(self.value)
 
 
 class AutoStrEnumUpperCase(str, Enum):
     @staticmethod
-    def _generate_next_value_(name: str, start: int, count: int, last_values: list) -> str:
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list
+    ) -> str:
         return name
-    
+
     def __str__(self):
-        return str(self.value)
+        return str(self.value)