everysk-lib 1.10.2__cp312-cp312-win_amd64.whl

everysk/sdk/entities/secrets/script.py

@@ -0,0 +1,119 @@
+###############################################################################
+#
+# (C) Copyright 2025 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+import base64
+from collections.abc import Callable
+from inspect import isclass
+from typing import Any
+
+import six
+
+from everysk.config import settings
+from everysk.core.exceptions import FieldValueError, WorkerError
+from everysk.core.object import BaseDict
+from everysk.core.string import import_from_string
+from everysk.sdk.base import BaseSDK
+from everysk.sdk.entities import File
+from everysk.sdk.entities.base import QueryMetaClass
+
+###############################################################################
+#  Class Implementation
+###############################################################################
+
+
+class SecretsScript(BaseDict, BaseSDK):
+    _klass: Callable = None
+
+    def __init__(self, _klass: Callable) -> None:
+        super().__init__(_klass=None)
+
+        if _klass is not None and not isclass(_klass):
+            try:
+                _klass = import_from_string(settings.EVERYSK_SDK_ENTITIES_MODULES_PATH[_klass])
+            except KeyError:
+                raise FieldValueError(
+                    f"The _klass value '{_klass}' must be a class or a string with the class name."
+                ) from KeyError
+
+        self._klass = _klass
+
+    def _process__klass(self, value: Any) -> Any:
+        """
+        This method is used to process the '_klass' attribute.
+        """
+        return value.__name__
+
+    def _from_base_64(self, file_data: str) -> str:
+        """
+        Decodes the base 64 string data to normal sting.
+
+        Args:
+            file_data (str or bytes): The input data to be decoded. This can be a string or bytes.
+
+        Returns:
+            str: The decoded version of the input data as a string.
+        """
+        return six.ensure_str(base64.b64decode(six.ensure_str(file_data)))
+
+    def _get_secrets_from_file(self, query: str | BaseDict | list[str], variant: str, workspace: str) -> str:
+        secrets_file = File.script.fetch(query, variant, workspace)
+
+        if not secrets_file:
+            return None
+
+        return self._from_base_64(secrets_file.data)
+
+    def normalize(self, value: str | BaseDict | list[str], variant: str, workspace: str = None) -> str:
+        normalized_value: str = None
+
+        if variant == 'selectSecrets':
+            from everysk.sdk.entities import Secrets
+
+            normalized_value = Secrets.value_from_path(value)
+
+        elif variant in {'metaString', 'password'}:
+            normalized_value = value
+
+        elif variant in {'selectFile', 'tagLatest', 'linkLatest'}:
+            normalized_value = self._get_secrets_from_file(value, variant, workspace)
+
+        elif variant == 'previousWorkers':
+            if isinstance(value, str) and not File.validate_id(value):
+                normalized_value = value
+
+            else:
+                normalized_value = self._get_secrets_from_file(value, variant, workspace)
+
+        else:
+            raise WorkerError(f'Unsupported secrets variant `{variant}`')
+
+        return normalized_value
+
+
+class SecretsScriptMetaClass(QueryMetaClass):
+    """
+    Metaclass for the Script class that allows for the script attribute to be accessed
+    directly from the entity class.
+
+    Example:
+        To access the script attribute from the entity class:
+        >>> MyClass.script
+        Script()
+
+    Notes:
+        This metaclass overrides the __getatrribute__ method to enable direct access
+    """
+
+    def __getattribute__(cls, __name: str) -> Any:
+        """
+        Get the script attribute from the entity class.
+        """
+        if __name == 'script':
+            return SecretsScript(cls)
+        return super().__getattribute__(__name)

everysk/sdk/entities/secrets/settings.py

@@ -0,0 +1,17 @@
+###############################################################################
+#
+# (C) Copyright 2023 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+from everysk.core.fields import IntField, RegexField, StrField
+
+###############################################################################
+#   Settings Implementation
+###############################################################################
+SECRETS_ID_PREFIX = StrField(default='scrt_', readonly=True)
+SECRETS_ID_REGEX = RegexField(default=r'^scrt_[a-zA-Z0-9]{25}', readonly=True)
+SECRETS_ID_MAX_LENGTH = IntField(default=30, readonly=True)  # len(SECRETS_ID_PREFIX) + ENTITY_ID_LENGTH

everysk/sdk/entities/settings.py

@@ -0,0 +1,48 @@
+###############################################################################
+#
+# (C) Copyright 2023 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+
+###############################################################################
+#   Imports
+###############################################################################
+from everysk.core.fields import IntField, StrField, SetField, ListField
+
+###############################################################################
+#   Settings Implementation
+###############################################################################
+ENTITY_NAME_MAX_LENGTH = IntField(default=200, readonly=True)
+ENTITY_NAME_MIN_LENGTH = IntField(default=1, readonly=True)
+
+ENTITY_DESCRIPTION_MAX_LEN = IntField(default=500, readonly=True)
+ENTITY_DESCRIPTION_MIN_LEN = IntField(default=0, readonly=True)
+
+ENTITY_MAX_TAG_LENGTH = IntField(default=252, readonly=True)
+ENTITY_MIN_TAG_LENGTH = IntField(default=1, readonly=True)
+ENTITY_MAX_TAG_SIZE = IntField(default=32, readonly=True)
+ENTITY_MIN_TAG_SIZE = IntField(default=0, readonly=True)
+
+ENTITY_DEFAULT_VERSION = StrField(default='v1', readonly=True)
+ENTITY_ID_LENGTH = IntField(default=25, readonly=True)
+
+ENTITY_MAX_TAG_SIZE = IntField(default=32, readonly=True)
+ENTITY_MIN_TAG_SIZE = IntField(default=0, readonly=True)
+
+ENTITY_LINK_UID_MAX_LENGTH = IntField(default=128, readonly=True)
+ENTITY_LINK_UID_MIN_LENGTH = IntField(default=1, readonly=True)
+
+DEFAULT_QUERY_OFFSET = IntField(default=0, readonly=True)
+DEFAULT_QUERY_PAGE_SIZE = IntField(default=20, readonly=True)
+DEFAULT_QUERY_LIMIT = IntField(default=None)
+
+ENTITY_RETRIEVE_BATCH_SIZE = IntField(default=1000, readonly=True)
+
+QUERY_OPERATORS = SetField(default={'<=', '>=', '<', '>', '=', '!=', 'IN', 'NOT_IN'}, readonly=True)
+
+ENTITY_BASE_CURRENCY_DEFAULT_LIST = SetField(default={'USD', 'EUR', 'GBP', 'JPY', 'CNY', 'AUD', 'CAD', 'CHF', 'CNH', 'HKD', 'NZD', 'BRL'}, readonly=True)
+ENTITY_ALLOWED_QUERY_ATTRIBUTES_FOR_ALL_OPERATORS = ListField(default=['name', 'date', 'link_uid', 'created_on', 'updated_on'], readonly=True)

everysk/sdk/entities/tags.py

@@ -0,0 +1,174 @@
+###############################################################################
+#
+# (C) Copyright 2023 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+from types import NoneType
+from typing import Any, Self
+from collections.abc import Iterable
+
+from six import string_types
+
+from everysk.config import settings
+from everysk.core.datetime import DateTime, Date
+from everysk.core.exceptions import FieldValueError
+from everysk.core.number import is_float_convertible
+from everysk.core.string import normalize_string, to_string
+from everysk.sdk.entities.base_list import EntityList
+
+
+###############################################################################
+#   Tags Class Implementation
+###############################################################################
+class Tags(EntityList):
+    """
+    A specialized list for handling tags.
+
+    This class is a subclass of EntityList and provides specific validation for tags, including
+    size limits and pattern matching.
+
+    Attributes:
+        min_size (int): The minimum allowed size for the list (default is 1).
+        max_size (int): The maximum allowed size for the list (default is the value from settings).
+
+    Example:
+        To create a Tags for handling tags:
+        tags = Tags()
+    """
+    min_size: int = 1
+    max_size: int = settings.ENTITY_MAX_TAG_LENGTH
+
+    def __init__(self, *args):
+        """
+        Initialize the Tags.
+
+        Args:
+            *args: Optional initial elements to populate the list.
+
+        Example:
+            To create an Tags with initial elements:
+            >>> my_list = Tags(['tag1', 'tag2', 'tag3'])
+        """
+        if args:
+            try:
+                args = (list(dict.fromkeys(self.unify(args[0]))), )
+            except TypeError:
+                raise FieldValueError('Unsupported format in Tags.') from TypeError
+        super().__init__(*args)
+
+    def _validate(self, value: Any) -> str:
+        """
+        Validate a tag value.
+
+        Args:
+            value (str): The tag value to be validated.
+
+        Raises:
+            FieldValueError: If the tag value is invalid based on the specified criteria.
+
+        Returns:
+            str: The validated tag value.
+
+        Criteria:
+            - The value must be a string.
+            - The value's length must be between min_size ({min_size}) and max_size ({max_size}).
+            - The value must consist of only lowercase letters, digits, and underscores.
+            - The value cannot be empty.
+
+        Raises:
+            FieldValueError: If the tag value does not meet the specified criteria.
+        """
+        if isinstance(value, list) or isinstance(value, dict):
+            raise FieldValueError(f'Unsupported format in Tags: {type(value)}')
+        elif value == '' or value is Undefined:
+            value = str(None)
+        elif is_float_convertible(value) or value.__class__ in [NoneType, bool]:
+            value = str(value)
+        elif value.__class__ in [DateTime, Date]:
+            value = value.strftime('%Y%m%d')
+        elif not isinstance(value, string_types):
+            raise FieldValueError(f'Unsupported format in Tags: {type(value)}')
+
+        value = to_string(''.join(x if x.isalnum() else '_' for x in normalize_string(value))).lower()
+
+        if (
+            self.min_size is not None and self.min_size > len(value) or
+            self.max_size is not None and self.max_size < len(value)
+        ):
+            raise FieldValueError(f"Tags: '{value}' size it's not between {self.min_size} and {self.max_size}")
+
+        return value
+
+    def insert(self, __index: int, __object: Any) -> None:
+        """
+        Insert an object at a specified index if the object does not exist with validation.
+
+        Args:
+            __index (int): The index at which to insert the object.
+            __object: The object to be inserted.
+        """
+        __object = self._validate(__object)
+        if __object not in self:
+            super().insert(__index, __object)
+
+    def append(self, __object: Any) -> None:
+        """
+        Append an object to the list if the object does not exist with validation.
+
+        Args:
+            __object: The object to be appended.
+        """
+        __object = self._validate(__object)
+        if __object not in self:
+            super().append(__object)
+
+    def extend(self, __iterable: Iterable) -> None:
+        """
+        Extend the list with values from an iterable if the value does not exist with validation.
+
+        Args:
+            __iterable (Iterable): An iterable containing values to be added to the list.
+        """
+        order_values: dict = {}
+        for value in __iterable:
+            value: str = self._validate(value)
+            if value not in self:
+                order_values[value] = None
+        super().extend(list(order_values.keys()))
+
+    @classmethod
+    def unify(cls, tag_set: Any, reference_tags: list[Any] = None) -> Self:
+        """
+        Unify a set of tags with a reference set of tags.
+
+        Args:
+            tag_set (list): The set of tags to be unified.
+            reference_tags (list): The reference set of tags.
+
+        Returns:
+            list: The unified set of tags.
+
+        Example:
+            To unify a set of tags with a reference set of tags:
+            >>> unified_tags = Tags.unify_tags([['tag1', 'tag2'], ['tag3', 'tag4']], ['tag5', 'tag6'])
+        """
+        unified_tags: Self = cls()
+
+        if not tag_set:
+            return unified_tags
+        elif isinstance(tag_set, (int, float)):
+            tag_set = [tag_set]
+
+        for tags in tag_set:
+            if tags is not False and not tags and reference_tags:
+                unified_tags.extend(reference_tags)
+            elif isinstance(tags, list):
+                unified_tags.extend(cls.unify(tags, reference_tags))
+            else:
+                unified_tags.append(tags)
+
+        return unified_tags

everysk/sdk/entities/worker_execution/base.py

@@ -0,0 +1,307 @@
+###############################################################################
+#
+# (C) Copyright 2025 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+from typing import Any, Self
+
+from everysk.config import settings
+from everysk.core.datetime import DateTime
+from everysk.core.fields import BoolField, DateTimeField, DictField, FloatField, IntField, ListField, StrField
+from everysk.core.object import BaseDict
+from everysk.sdk.entities.base import BaseEntity
+from everysk.sdk.entities.query import Query
+
+
+###############################################################################
+#   Result Class Implementation
+###############################################################################
+class Result(BaseDict):
+    status = StrField(default='ERROR', choices=('OK', 'ERROR', 'UNKNOW'))
+    data: list | dict | None = None
+    log = ListField()
+
+
+###############################################################################
+#   ResultField Class Implementation
+###############################################################################
+class ResultField(DictField):
+    attr_type: Result | BaseDict | dict = Result | BaseDict | dict
+
+    def clean_value(self, value: Any) -> Result | None:
+        """
+        This method cleans the value of the field.
+
+        Args:s
+            value (Any): The value to be cleaned.
+
+        Returns:
+            Securities: The cleaned value.
+        """
+        if isinstance(value, dict):
+            value = Result(**value)
+
+        return super().clean_value(value)
+
+
+###############################################################################
+#   ParallelInfo Class Implementation
+###############################################################################
+class ParallelInfo(BaseDict):
+    index = IntField(default=settings.WORKER_EXECUTION_UNFORKED_PARALLEL_INDEX, required_lazy=True)
+    length = IntField(default=settings.WORKER_EXECUTION_UNFORKED_PARALLEL_LENGTH, required_lazy=True)
+
+
+###############################################################################
+#   ParallelInfoField Class Implementation
+###############################################################################
+class ParallelInfoField(DictField):
+    attr_type: ParallelInfo | BaseDict | dict = ParallelInfo | BaseDict | dict
+
+    def __init__(
+        self,
+        default: Any = None,
+        *,
+        required: bool = False,
+        readonly: bool = False,
+        required_lazy: bool = True,
+        empty_is_none: bool = False,
+        **kwargs,
+    ) -> None:
+        if default is None:
+            default = ParallelInfo()
+        super().__init__(
+            default=default,
+            required=required,
+            readonly=readonly,
+            required_lazy=required_lazy,
+            empty_is_none=empty_is_none,
+            **kwargs,
+        )
+
+    def clean_value(self, value: Any) -> Result | None:
+        """
+        This method cleans the value of the field.
+
+        Args:s
+            value (Any): The value to be cleaned.
+
+        Returns:
+            Securities: The cleaned value.
+        """
+        if isinstance(value, (dict, BaseDict)):
+            value = ParallelInfo(**value)
+
+        return super().clean_value(value)
+
+
+###############################################################################
+#   InputParams Class Implementation
+###############################################################################
+class InputParams(BaseDict):
+    worker_id = StrField(empty_is_none=True)
+    workflow_id = StrField(regex=settings.WORKFLOW_ID_REGEX, empty_is_none=True)
+
+    worker_execution_id = StrField(regex=settings.WORKER_EXECUTION_ID_REGEX, empty_is_none=True)
+    workflow_execution_id = StrField(regex=settings.WORKFLOW_EXECUTION_ID_REGEX, empty_is_none=True)
+
+    workspace = StrField(empty_is_none=True)
+    worker_type = StrField(default=Undefined, choices=settings.WORKER_TEMPLATE_TYPES)
+    script_inputs = DictField()
+    inputs_info = DictField()
+    parallel_info = ParallelInfoField()
+
+    def to_dict(self, add_class_path: bool = False, recursion: bool = False) -> dict:
+        """
+        This method is used to convert the object to a dictionary.
+        """
+        dct: dict = super().to_dict(add_class_path=add_class_path, recursion=recursion)
+
+        if isinstance(dct['parallel_info'], ParallelInfo):
+            dct['parallel_info'] = dct['parallel_info'].to_dict(add_class_path=add_class_path, recursion=recursion)
+
+        return dct
+
+
+###############################################################################
+#   InputParamsField Class Implementation
+###############################################################################
+class InputParamsField(DictField):
+    attr_type: InputParams | BaseDict | dict = InputParams | BaseDict | dict
+
+    def clean_value(self, value: Any) -> InputParams | None:
+        """
+        This method cleans the value of the field.
+
+        Args:s
+            value (Any): The value to be cleaned.
+
+        Returns:
+            Securities: The cleaned value.
+        """
+        if isinstance(value, dict):
+            value = InputParams(**value)
+
+        return super().clean_value(value)
+
+
+###############################################################################
+#   WorkerExecution Class Implementation
+###############################################################################
+class WorkerExecution(BaseEntity):
+    id = StrField(regex=settings.WORKER_EXECUTION_ID_REGEX, required_lazy=True, empty_is_none=True)
+
+    result = ResultField()
+    storage = BoolField(default=False)
+    input_params = InputParamsField(required_lazy=True)
+    storage_input_params = BoolField(default=False)
+
+    parallel_info = ParallelInfoField()
+    status = StrField(default=settings.WORKER_EXECUTION_STATUS_PREPARING, choices=settings.WORKER_EXECUTION_STATUS_LIST)
+    execution_type = StrField(default=Undefined, choices=settings.WORKER_EXECUTION_TYPE_LIST, required_lazy=True)
+    start_time = DateTimeField()
+    end_time = DateTimeField()
+    duration = FloatField(default=0.0)
+    cpu_time = FloatField(default=0.0)
+    process_cpu_time = FloatField(default=0.0)
+
+    workflow_execution_id = StrField(regex=settings.WORKFLOW_EXECUTION_ID_REGEX, required_lazy=True, empty_is_none=True)
+    workflow_id = StrField(regex=settings.WORKFLOW_ID_REGEX, required_lazy=True, empty_is_none=True)
+    workflow_name = StrField(required_lazy=True, empty_is_none=True)
+    worker_id = StrField(regex=settings.WORKER_ID_REGEX, required_lazy=True, empty_is_none=True)
+    worker_name = StrField(required_lazy=True, empty_is_none=True)
+    worker_type = StrField(default=Undefined, choices=settings.WORKER_TEMPLATE_TYPES)
+
+    @staticmethod
+    def get_id_prefix() -> str:
+        """
+        Returns the prefix of the Worker Execution id field value.
+
+        Returns:
+            str: The prefix of the Worker Execution id field value.
+
+        Usage:
+            >>> WorkerExecution.get_id_prefix()
+            'wkex_'
+
+        Notes:
+            The prefix is typically used to distinguish Worker Execution IDs from other types of IDs.
+        """
+        return settings.WORKER_EXECUTION_ID_PREFIX
+
+    def generate_id(self) -> str:
+        """
+        Generate a unique ID for an entity instance.
+
+        Returns:
+            str: The generated unique ID.
+
+        Example:
+            To generate a unique ID for an entity instance:
+            >>> unique_id = MyEntity().generate_id()
+        """
+        raise NotImplementedError
+
+    def to_dict(self, add_class_path: bool = False, recursion: bool = False) -> dict:
+        """
+        This method is used to convert the object to a dictionary.
+        """
+        dct: dict = super().to_dict(add_class_path=add_class_path, recursion=recursion)
+
+        if isinstance(dct['parallel_info'], ParallelInfo):
+            dct['parallel_info'] = dct['parallel_info'].to_dict(add_class_path=add_class_path, recursion=recursion)
+
+        if isinstance(dct['result'], Result):
+            dct['result'] = dct['result'].to_dict(add_class_path=add_class_path, recursion=recursion)
+
+        if isinstance(dct['input_params'], InputParams):
+            dct['input_params'] = dct['input_params'].to_dict(add_class_path=add_class_path, recursion=recursion)
+
+        if add_class_path is False:
+            if self.duration is None:
+                now = DateTime.now()
+                start = self.start_time if self.start_time else now
+                end = self.end_time if self.end_time else now
+                dct['duration'] = (end - start).total_seconds()
+
+            dct['started'] = self.start_time.timestamp() if self.start_time else None
+            dct['trigger'] = self.execution_type
+
+            if dct['result'] is not None:
+                dct['result'] = dct.get('result', {}).get('data', None)
+
+            dct.pop('execution_type')
+            dct.pop('start_time')
+            dct.pop('end_time')
+            dct.pop('storage')
+            dct.pop('storage_input_params')
+
+        return dct
+
+    def _check_entity_to_query(self) -> bool:
+        """
+        Check the entity object to query.
+
+        Returns:
+            bool: True if the entity object is valid.
+        """
+        return True
+
+    def _check_query(self, query: Query) -> bool:
+        """
+        Check the query object.
+
+        Args:
+            query (Query): The query object.
+
+        Returns:
+            bool: True if the query object is valid.
+        """
+        return True
+
+    def _mount_query(self, query: Query) -> Query:
+        """
+        Mount the query object.
+
+        Args:
+            query (Query): The query object.
+
+        Returns:
+            Query: The query object.
+        """
+        if self.workflow_execution_id is not None:
+            query = query.where('workflow_execution_id', self.workflow_execution_id)
+
+        return query
+
+    @classmethod
+    def get_input_params(cls, entity_id: str) -> InputParams:
+        """
+        Get the input_params of a Worker Execution with the given ID.
+
+        Args:
+            entity_id (str): The ID of the Worker Execution.
+
+        Returns:
+            InputParams: The input_params of the Worker Execution.
+
+        Raises:
+            ValueError: If the entity ID is invalid.
+            ValueError: If the entity is not found.
+        """
+        if cls.validate_id(entity_id) is False:
+            raise ValueError(f'Invalid Entity ID: {entity_id}')
+
+        entity: Self | None = cls.retrieve(entity_id)
+
+        if entity is None:
+            raise ValueError(f'Entity not found. Entity ID: {entity_id}')
+
+        if entity.input_params.worker_execution_id is None:
+            entity.input_params.worker_execution_id = entity.id  # pylint: disable=attribute-defined-outside-init
+
+        return entity.input_params