everysk-lib 1.10.2__cp312-cp312-win_amd64.whl

everysk/sdk/engines/cache.py

@@ -0,0 +1,185 @@
+###############################################################################
+#
+# (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, Iterable
+
+from everysk.config import settings
+from everysk.core.fields import IntField, StrField
+from everysk.sdk.base import BaseSDK
+
+###############################################################################
+#   UserCache Class Implementation
+###############################################################################
+class UserCache(BaseSDK):
+
+    timeout_default = IntField(default=settings.ENGINES_CACHE_EXECUTION_EXPIRATION_TIME, max=settings.ENGINES_CACHE_EXECUTION_EXPIRATION_TIME)
+    prefix = StrField()
+
+    def _validate_timeout(self, timeout: int) -> None:
+        """
+        Validate the timeout value for cache operations.
+
+        Args:
+            timeout (int): The timeout value to validate.
+
+        Raises:
+            ValueError: If the timeout value is not a positive integer or exceeds the default expiration time.
+        """
+        if not isinstance(timeout, int) or timeout <= 0 or timeout > settings.ENGINES_CACHE_EXECUTION_EXPIRATION_TIME:
+            raise ValueError('Invalid timeout value. The timeout value should be an integer greater than 0 and less than or equal to the default expiration time.')
+
+    def get(self, key: str) -> Any:
+        """
+        Get the value of a key from the cache.
+
+        Args:
+            key (str): The key to get the value of.
+
+        Returns:
+            Any: The value of the key.
+
+        Example:
+            >>> cache = UserCache()
+            >>> cache.get('key')
+        """
+        return self.get_response(self_obj=self, params={'key': key})
+
+    def get_multi(self, keys: list[str]) -> dict[str, Any]:
+        """
+        Get the values of multiple keys from the cache.
+
+        Args:
+            keys (list[str]): The keys to get the values of.
+
+        Returns:
+            dict[str, Any]: The values of the keys.
+
+        Example:
+            >>> cache = UserCache()
+            >>> cache.get_multi(['key1', 'key2'])
+            {
+                'key1': 'value1',
+                'key2': 'value2'
+            }
+        """
+        return self.get_response(self_obj=self, params={'keys': keys})
+
+    def set(self, key: str, value: Any, timeout: int = settings.ENGINES_CACHE_EXECUTION_EXPIRATION_TIME) -> bool:
+        """
+        Set the value of a key in the cache.
+
+        Args:
+            key (str): The key to set the value of.
+            value (Any): The value to set.
+            timeout (int): The expiration time of the key in seconds.
+
+        Returns:
+            bool: True if the key is set, False otherwise.
+
+        Example:
+            >>> cache = UserCache()
+            >>> cache.set('key', 'value')
+        """
+        self._validate_timeout(timeout)
+        return self.get_response(self_obj=self, params={'key': key, 'value': value, 'timeout': timeout})
+
+    def set_multi(self, data_dict: dict, timeout: int = settings.ENGINES_CACHE_EXECUTION_EXPIRATION_TIME) -> list:
+        """
+        Set the values of multiple keys in the cache.
+
+        Args:
+            data_dict (dict): The keys and values to set.
+            timeout (int): The expiration time of the keys in seconds.
+
+        Returns:
+            list: The keys that are set.
+
+        Example:
+            >>> cache = UserCache()
+            >>> cache.set_multi({'key1': 'value1', 'key2': 'value2'})
+            ['key1', 'key2']
+        """
+        self._validate_timeout(timeout)
+        return self.get_response(self_obj=self, params={'data_dict': data_dict, 'timeout': timeout})
+
+    def incr(self, key: str, delta: int = 1, initial_value: Any = None, timeout: int = settings.ENGINES_CACHE_EXECUTION_EXPIRATION_TIME) -> int:
+        """
+        Increment the value of a key in the cache.
+
+        Args:
+            key (str): The key to increment the value of.
+            delta (int): The amount to increment the value by.
+            initial_value (Any): The initial value of the key.
+            timeout (int): The expiration time of the key in seconds.
+
+        Returns:
+            int: The new value of the key.
+
+        Example:
+            >>> cache = UserCache()
+            >>> cache.incr('key', 1, 0)
+            1
+        """
+        self._validate_timeout(timeout)
+        return self.get_response(self_obj=self, params={'key': key, 'delta': delta, 'initial_value': initial_value, 'timeout': timeout})
+
+    def decr(self, key: str, delta: int = 1, initial_value: Any = None, timeout: int = settings.ENGINES_CACHE_EXECUTION_EXPIRATION_TIME) -> int | None:
+        """
+        Decrement the value of a key in the cache.
+
+        Args:
+            key (str): The key to decrement the value of.
+            delta (int): The amount to decrement the value by.
+            initial_value (Any): The initial value of the key.
+            timeout (int): The expiration time of the key in seconds.
+
+        Returns:
+            int: The new value of the key.
+
+        Example:
+            >>> cache = UserCache()
+            >>> cache.decr('key', 1, 0)
+            0
+        """
+        self._validate_timeout(timeout)
+        return self.get_response(self_obj=self, params={'key': key, 'delta': delta, 'initial_value': initial_value, 'timeout': timeout})
+
+    def delete(self, key: bytes | str | Iterable) -> bool:
+        """
+        Delete a key from the cache.
+
+        Args:
+            key (bytes | str | Iterable): The key to delete. Can be a single key or an iterable of keys.
+
+        Returns:
+            bool: True if the key is deleted, False otherwise.
+
+        Example:
+            >>> cache = UserCache()
+            >>> cache.delete('key')
+            True
+        """
+        return self.get_response(self_obj=self, params={'key': key})
+
+    def delete_multi(self, keys: Iterable) -> bool:
+        """
+        Delete multiple keys from the cache.
+
+        Args:
+            keys (Iterable): The keys to delete. Can be a list or any iterable of keys.
+
+        Returns:
+            bool: True if the keys are deleted, False otherwise.
+
+        Example:
+            >>> cache = UserCache()
+            >>> cache.delete_multi(['key1', 'key2'])
+            True
+        """
+        return self.get_response(self_obj=self, params={'keys': keys})

everysk/sdk/engines/compliance.py

@@ -0,0 +1,37 @@
+###############################################################################
+#
+# (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 everysk.sdk.base import BaseSDK
+
+
+###############################################################################
+#   Compliance Class Implementation
+###############################################################################
+class Compliance(BaseSDK):
+
+    @classmethod
+    def check(cls, rules: list, datastore: list, metadata: dict = None) -> dict:
+        """
+        Check compliance of data against rules.
+
+        Args:
+            rules (list): The rules to check against.
+            datastore (list): The data to check.
+            metadata (dict, optional): The metadata to use for checking. Default is None.
+
+        Returns:
+            dict: The compliance check result.
+
+        Example:
+            >>> Compliance.check(rules=[{'rule': 'rule1'}, {'rule': 'rule2'}], datastore=[{'data': 'data1'}, {'data': 'data2'}])
+            {
+                'compliance': True
+            }
+        """
+        return cls.get_response(params={'rules': rules, 'datastore': datastore, 'metadata': metadata})

everysk/sdk/engines/cryptography.py

@@ -0,0 +1,69 @@
+###############################################################################
+#
+# (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.
+#
+###############################################################################
+import string
+import secrets
+import uuid
+
+from everysk.config import settings
+
+
+ALPHANUMERIC = string.ascii_letters + string.digits
+SYMBOL_ID_MAX_LEN = settings.SYMBOL_ID_MAX_LEN
+
+
+###############################################################################
+#   Public Functions Implementation
+###############################################################################
+def generate_random_id(length: int, characters: str = ALPHANUMERIC) -> str:
+    """
+    Generate a random ID based on the specified length and characters.
+
+    Args:
+        length (int): The desired length for the random ID.
+        characters (str, optional): The characters to use for generating the ID.
+            Default is alphanumeric characters.
+
+    Returns:
+        str: The generated random ID consisting of the specified characters.
+
+    Example:
+        >>> generate_random_id(18)
+        'xiXwQuig6cI11ny095'
+
+        >>> generate_random_id(5, 'abc')
+        'cbacb'
+    """
+    return ''.join(secrets.choice(characters) for i in range(length))
+
+def generate_unique_id():
+    """
+    Generate a unique ID with fixed length (32 characters).
+
+    Returns:
+        str: The generated unique ID consisting of hexadecimal characters.
+
+    Example:
+        >>> generate_unique_id()
+        'dbdc803042ff48e19a344ad080a102dd'
+    """
+    return uuid.uuid4().hex
+
+def generate_short_random_id() -> str:
+    """
+    Generate a random ID with a fixed length of 8 characters.
+
+    Returns:
+        str: The generated unique ID consisting of alphanumeric characters.
+
+    Example:
+        >>> generate_short_random_id()
+        'u0tmNqHP'
+    """
+    return generate_random_id(length=settings.SIMPLE_UNIQUE_ID_LENGTH)

everysk/sdk/engines/expression.pyi

@@ -0,0 +1,55 @@
+# This file was generated by Nuitka
+
+# Stubs included by default
+from __future__ import annotations
+from everysk.sdk.engines.expression.base import ExpressionEngine
+
+
+__name__ = ...
+
+
+
+# Modules used internally, to allow implicit dependencies to be seen:
+import os
+import everysk
+import everysk.sdk
+import everysk.sdk.engines
+import typing
+import lark
+import lark.tree
+import everysk.config
+import everysk.core
+import everysk.core.log
+import _frozen_importlib_external
+import functools
+import importlib
+import inspect
+import pkgutil
+import collections
+import collections.abc
+import numpy
+import pandas
+import everysk.core.datetime
+import everysk.core.datetime.Date
+import everysk.core.datetime.DateTime
+import everysk.core.datetime.date_settings
+import everysk.sdk.engines.helpers
+import everysk.sdk.engines.helpers.transform
+import datetime
+import everysk.core.datetime.date_mixin
+import everysk.sdk.engines.helpers.algorithms
+import everysk.sdk.engines.helpers.mathematical
+import collections.OrderedDict
+import everysk.sdk.brutils
+import everysk.sdk.brutils.cnpj
+import everysk.sdk.engines.helpers.formater
+import re
+import unicodedata
+import everysk.sdk.engines.cryptography
+import unittest
+import copy
+import unittest.mock
+import everysk.core.datetime.calendar
+import lark.visitors
+import decimal
+import lark.exceptions

everysk/sdk/engines/helpers.pyi

@@ -0,0 +1,26 @@
+# This file was generated by Nuitka
+
+# Stubs included by default
+from __future__ import annotations
+
+
+__name__ = ...
+
+
+
+# Modules used internally, to allow implicit dependencies to be seen:
+import os
+import pandas
+import numpy
+import math
+import decimal
+import everysk
+import everysk.core
+import everysk.core.datetime
+import everysk.core.datetime.DateTime
+import everysk.sdk
+import everysk.sdk.engines
+import functools
+import typing
+import _frozen_importlib_external
+import unittest

everysk/sdk/engines/lock.py

@@ -0,0 +1,120 @@
+###############################################################################
+#
+# (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 uuid import uuid1
+
+from everysk.config import settings
+from everysk.core.fields import StrField, FloatField, BoolField
+from everysk.core.exceptions import InvalidArgumentError
+from everysk.sdk.base import BaseSDK
+
+###############################################################################
+#   UserLock Class Implementation
+###############################################################################
+class UserLock(BaseSDK):
+    """
+    UserLock class for acquiring and releasing locks.
+    This class provides methods to acquire a lock for a given token, release the lock,
+    and get information about the lock status.
+    It is used to manage locks in a distributed system to
+    prevent multiple processes from accessing the same resource simultaneously.
+
+    Attributes:
+        token (str): The unique identifier for the lock.
+        name (str): The name of the lock.
+        timeout (int): The expiration time for the lock in seconds.
+
+    Example:
+        >>> user_lock = UserLock(name='my_lock')
+        >>> user_lock.acquire()
+        UserLock(token='generated_token', name='my_lock', timeout=30)
+        >>> user_lock.get_lock_info()
+        {'locked': True, 'name': 'my_lock'}
+        >>> user_lock.release()
+        None
+    """
+    token = StrField(default=None)
+    name = StrField(default=None, required=True)
+    timeout = FloatField(default=settings.USER_CACHE_LOCK_EXPIRATION_TIME, min_size=settings.USER_CACHE_LOCK_MIN_EXPIRATION_TIME, max_size=settings.USER_CACHE_LOCK_MAX_EXPIRATION_TIME)
+    blocking = BoolField(default=True) # If True, the lock will block until it can be acquired.
+
+    def acquire(self, token: str = None, blocking: bool = None, blocking_timeout: float = None) -> bool:
+        """
+        Acquire a lock for a given token.
+
+        Args:
+            token (str | None): The token to use for the lock. If None, a new token will be generated.
+            blocking (bool | None): If True, wait until the lock is acquired. Defaults to None.
+            blocking_timeout (float | None): The maximum number of seconds to wait for the lock. Defaults to None.
+
+        Returns:
+            bool: True if the lock was acquired successfully, False otherwise.
+
+        Example:
+            >>> user_lock = UserLock(name='my_lock')
+            >>> user_lock.acquire()
+            True
+        """
+        if not token and not self.token:
+            self.token = uuid1().hex
+        elif token:
+            self.token = token
+
+        return self.get_response(self_obj=self, params={'token': token, 'blocking': blocking, 'blocking_timeout': blocking_timeout})
+
+
+    def release(self, force: bool = False) -> None:
+        """
+        Release the lock for a given identifier.
+
+        Args:
+            force (bool): If True, force the release of the lock even if it is not owned.
+                This will delete the key from Redis. Defaults to False.
+
+        Example:
+            >>> UserLock.release('my_lock')
+            None
+        """
+        if not self.token:
+            raise InvalidArgumentError("Cannot release an unlocked lock")
+
+        return self.get_response(self_obj=self, params={'force': force})
+
+    def do_release(self, expected_token: str) -> None:
+        """
+        Release the lock for a given token.
+        This method is used to release a lock that was previously acquired.
+
+        Args:
+            expected_token (str): The unique token for the lock to release.
+
+        Example:
+            >>> user_lock = UserLock(name='my_lock')
+            >>> user_lock.do_release(token='token')
+            None
+        """
+        if not expected_token:
+            raise InvalidArgumentError("Cannot release an unlocked lock")
+
+        return self.get_response(self_obj=self, params={'expected_token': expected_token})
+
+    def get_lock_info(self) -> dict:
+        """
+        Get information about the lock status.
+        This method returns a dictionary containing information about the lock status.
+
+        Returns:
+            dict: A dictionary containing the lock status and other information.
+
+        Example:
+            >>> user_lock = UserLock(name='my_lock')
+            >>> user_lock.get_lock_info()
+            {'locked': True, 'name': 'my_lock'}
+        """
+        return self.get_response(self_obj=self)