everysk-lib 1.10.2__cp312-cp312-win_amd64.whl

everysk/core/undefined.py

@@ -0,0 +1,70 @@
+###############################################################################
+#
+# (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 typing import Any, Self
+
+
+## Do not use this class, use the constant Undefined that is already defined in the python builtins. ##
+class UndefinedType:
+    """
+    The UndefinedType class is used to represent an undefined value in the Everysk framework.
+    This class is designed to be immutable and to always represent the same undefined value.
+    We use it as default values for function parameters and class attributes to indicate that
+    the value is not set and to differentiate it from None or other possible values.
+    """
+
+    default_error_message = 'This object is immutable.'
+    default_parse_string = '__UNDEFINED_VALUE__'
+    default_repr_string = '<Undefined value>'
+    block = False
+
+    def __init__(self) -> None:
+        if self.block:
+            raise NotImplementedError('Do not use this class, use the constant Undefined.')
+
+    def __bool__(self) -> bool:
+        """Undefined object is always False"""
+        return False
+
+    def __copy__(self) -> Self:
+        """To keep consistence, this object will always be the same."""
+        return self
+
+    def __delattr__(self, name: str) -> None:
+        """We could not delete attributes from this object."""
+        raise AttributeError(self.default_error_message)
+
+    def __deepcopy__(self, memo: dict | None = None) -> Self:
+        """To keep consistence, this object will always be the same."""
+        return self
+
+    def __eq__(self, value: object) -> bool:
+        """For an object created from the UndefinedType class to be equal to another, the classes must be equal."""
+        return isinstance(value, type(self))
+
+    def __getattr__(self, name: str) -> Any:
+        """Undefined object don't have attributes."""
+        raise AttributeError(self.default_error_message)
+
+    def __hash__(self) -> int:
+        """Must return an int that is used as hash for this object."""
+        return id(self)
+
+    def __repr__(self) -> str:
+        """Fixed to be the same every time."""
+        return self.default_repr_string
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """We can't set any attribute to this object."""
+        if self.block:
+            raise AttributeError(self.default_error_message)
+
+    def __str__(self) -> str:
+        """Fixed to be the same every time."""
+        return self.default_repr_string

everysk/core/unittests.py

@@ -0,0 +1,73 @@
+###############################################################################
+#
+# (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.
+#
+###############################################################################
+__all__ = ['TestCase', 'mock', 'skip', 'skipUnless', 'SkipTest', 'skipIf']
+
+import difflib
+import pprint
+from time import time
+from typing import Any
+from unittest import TestCase as PythonTestCase, mock, skip, skipUnless, SkipTest, skipIf
+from unittest.util import _common_shorten_repr
+from warnings import warn
+
+from everysk.config import settings
+from everysk.core.object import BaseDict
+
+
+###############################################################################
+#   TestCase Class Implementation
+###############################################################################
+class TestCase(PythonTestCase):
+
+    def _callTestMethod(self, method: callable) -> None:
+        # For some tests the time could not pass 1 second, gzip tests for example.
+        # So we use mock to fix the time for the tests.
+        original_time = time()
+        with mock.patch('time.time', return_value=original_time):
+            # We could not use super here because the stacklevel would be wrong
+            if method() is not None:
+                warn(
+                    f'It is deprecated to return a value that is not None from a test case ({method})',
+                    DeprecationWarning,
+                    stacklevel=3
+                )
+
+    def assertDictEqual(self, d1: dict | BaseDict, d2: dict | BaseDict, msg: str = None):
+        # pylint: disable=protected-access
+        self.assertIsInstance(d1, (dict, BaseDict), 'First argument is not a dictionary')
+        self.assertIsInstance(d2, (dict, BaseDict), 'Second argument is not a dictionary')
+
+        # We need to ensure that both objects are of the same type to proceed
+        if isinstance(d1, dict) and isinstance(d2, BaseDict):
+            d1 = type(d2)(**d1)
+
+        elif isinstance(d2, dict) and isinstance(d1, BaseDict):
+            d2 = type(d1)(**d2)
+
+        if d1 != d2:
+            standardMsg = '%s != %s' % _common_shorten_repr(d1, d2) # pylint: disable=consider-using-f-string, invalid-name
+            diff = ('\n' + '\n'.join(difflib.ndiff(
+                            pprint.pformat(d1).splitlines(),
+                            pprint.pformat(d2).splitlines())))
+            standardMsg = self._truncateMessage(standardMsg, diff) # pylint: disable=invalid-name
+            self.fail(self._formatMessage(msg, standardMsg))
+
+
+###############################################################################
+#   EveryskMagicMock Class Implementation
+###############################################################################
+class EveryskMagicMock(mock.MagicMock): # pylint: disable=too-many-ancestors
+
+    def __init__(self, *args: Any, **kw: Any) -> None:
+        super().__init__(*args, **kw)
+        # To avoid infinite recursion inside serialize.dumps we need to remove this method
+        delattr(self, settings.SERIALIZE_CONVERT_METHOD_NAME)
+
+mock.MagicMock = EveryskMagicMock

everysk/core/workers.py

@@ -0,0 +1,241 @@
+###############################################################################
+#
+# (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 traceback
+from typing import Any
+from uuid import uuid4
+
+from google.api_core.exceptions import (
+    AlreadyExists,
+    DeadlineExceeded,
+    ServiceUnavailable,
+    TooManyRequests
+)
+from google.cloud.tasks_v2 import (
+    CloudTasksClient,
+    CreateTaskRequest,
+    HttpMethod,
+    PauseQueueRequest,
+    ResumeQueueRequest,
+    Task,
+    Queue
+)
+from google.protobuf import duration_pb2
+
+from everysk.core.compress import compress, decompress
+from everysk.config import settings
+from everysk.core.fields import IntField, StrField
+from everysk.core.log import Logger
+from everysk.core.object import BaseObject
+from everysk.core.string import import_from_string
+
+
+log = Logger('everysk-workers')
+
+
+###############################################################################
+#   BaseGoogle Class Implementation
+###############################################################################
+class BaseGoogle(BaseObject):
+    ## Private attributes
+    _gtask: CloudTasksClient = None
+
+    ## Public attributes
+    google_task_project = StrField(default=settings.EVERYSK_GOOGLE_CLOUD_PROJECT)
+    google_task_location = StrField(default=settings.EVERYSK_GOOGLE_CLOUD_LOCATION)
+    worker_id = StrField(required=True)
+
+    @property
+    def gtask(self) -> CloudTasksClient:
+        # pylint: disable=protected-access
+        if self.__class__._gtask is None:
+            self.__class__._gtask = CloudTasksClient()
+
+        return self.__class__._gtask
+
+
+###############################################################################
+#   TaskGoogle Class Implementation
+###############################################################################
+class TaskGoogle(BaseGoogle):
+    ## Public attributes
+    google_task_name = StrField() # Must be a unique name if None is used, auto create this
+    timeout = IntField(default=600, min_size=15, max_size=1800) # https://cloud.google.com/tasks/docs/reference/rest/v2/projects.locations.queues.tasks
+    worker_url = StrField(required=True)
+
+    ## Private methods
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        # This facilitate to init it over pickle
+        self._received_kwargs = kwargs
+        if self.google_task_name is None:
+            self.google_task_name = f'{self.__class__.__name__}-{uuid4()}'
+
+    ## GTask methods
+    def gtask_queue_path(self) -> str:
+        return self.gtask.queue_path(
+            project=self.google_task_project,
+            location=self.google_task_location,
+            queue=self.worker_id
+        )
+
+    def gtask_task_path(self) -> str:
+        return self.gtask.task_path(
+            project=self.google_task_project,
+            location=self.google_task_location,
+            queue=self.worker_id,
+            task=self.google_task_name
+        )
+
+    def gtask_create_task_request(self, body: dict) -> CreateTaskRequest:
+        # https://cloud.google.com/tasks/docs/creating-http-target-tasks#createtask_method
+        if self.timeout is not None:
+            deadline = duration_pb2.Duration() # pylint: disable=no-member
+            deadline.FromSeconds(self.timeout)
+
+        task = {
+            'name': self.gtask_task_path(),
+            'dispatch_deadline': deadline,
+            'http_request': {
+                'http_method': HttpMethod.POST,
+                'url': f'{self.worker_url}/worker/{self.worker_id}',
+                'headers': self.get_headers(),
+                'body': compress(body, serialize='pickle')
+            }
+        }
+        return CreateTaskRequest(parent=self.gtask_queue_path(), task=task)
+
+    ## Public methods
+    def get_headers(self) -> dict:
+        """
+        Return the headers that must be used to receive the task.
+        Remember that body must be always a byte object, then on child
+        classes do like de example bellow.
+
+        Example:
+            >>> def get_headers(self) -> dict:
+            ...     headers = super().get_headers()
+            ...     headers['new_header'] = 'bla bla'
+            ...     return headers
+        """
+        return {'Content-type': 'application/octet-stream'}
+
+    def run(self) -> str:
+        """ This must return a str object to be used on worker logs """
+        pass
+
+    def send_start(self) -> Queue:
+        resume_queue_request = ResumeQueueRequest(name=self.gtask_queue_path())
+        return self.gtask.resume_queue(request=resume_queue_request)
+
+    def send_pause(self) -> Queue:
+        pause_queue_request = PauseQueueRequest(name=self.gtask_queue_path())
+        return self.gtask.pause_queue(request=pause_queue_request)
+
+    def save(self, timeout: float = 30.0, retry_times: int = 0) -> Task:
+        """
+        Saves this task on Google Cloud Tasks to be executed.
+        We will only retry if the Task Error is in (DeadlineExceeded, ServiceUnavailable, TooManyRequests).
+        Be careful, if the task name is random retry could duplicate the task.
+        # https://everysk.atlassian.net/browse/COD-1546
+
+        Args:
+            timeout (float, optional): Time to wait until the task is done. Defaults to 30.0.
+            retry_times (int, optional): Retry times if the task fails. Defaults to 0.
+        """
+        # Timeout could not be greater than 30 seconds
+        timeout = min(timeout, 30.0)
+
+        body = {'cls': self.get_full_doted_class_path(), 'kwargs': self._received_kwargs}
+        task = None
+        try:
+            task = self.gtask.create_task(request=self.gtask_create_task_request(body), timeout=timeout)
+
+        except AlreadyExists:
+            log.debug('Google task already exists: %s', self.gtask_task_path())
+
+        except (DeadlineExceeded, ServiceUnavailable, TooManyRequests) as error:
+            if retry_times > 0:
+                retry_times = retry_times - 1
+                task = self.save(timeout=timeout, retry_times=retry_times)
+            else:
+                raise error
+
+        return task
+
+
+###############################################################################
+#   WorkerGoogle Class Implementation
+###############################################################################
+class WorkerGoogle(BaseGoogle):
+    """
+    Example:
+        from flask import Flask, request
+        from everysk.core.fields import StrField
+        from everysk.core.workers import WorkerGoogle
+
+        WORKER_ID = 'worker-id'
+
+        class FirestoreSaveWorker(WorkerGoogle):
+            google_task_location: StrField(default='location', readonly=True)
+            google_task_project: StrField(default='project', readonly=True)
+            worker_id: StrField(default=WORKER_ID, readonly=True)
+
+        ## Flask app
+        app = Flask(__name__)
+
+        @app.route(f'/worker/{WORKER_ID}', methods=['POST'])
+        def firestore_save():
+            return FirestoreSaveWorker.worker_run(
+                headers=request.headers,
+                data=request.data
+            )
+
+        ## Main run function
+        if __name__ == "__main__":
+            app.run(host=settings.FLASK_HOST, port=settings.FLASK_PORT, debug=settings.DEBUG)
+    """
+
+    ## Public methods
+    def check_google_task(self, headers: dict) -> bool:
+        """ Check Google Task readers to ensure that the request come from then. """
+        queue_name = headers.get('X-Cloudtasks-Queuename', None)
+        user_agent = headers.get('User-Agent', None)
+        return queue_name == self.worker_id and user_agent == 'Google-Cloud-Tasks'
+
+    def run_task(self, cls: str, kwargs: dict) -> Any:
+        """
+        Run the task, if pause is activated from the Tread, stops
+        until the self.worker_start message arrives.
+        """
+        cls = import_from_string(cls)
+        task = cls(**kwargs)
+        return task.run()
+
+    @classmethod
+    def worker_run(cls, headers: dict, data: bytes, worker_id: str = None) -> None:
+        if worker_id is None:
+            worker = cls()
+        else:
+            worker = cls(worker_id=worker_id)
+
+        if not worker.check_google_task(headers):
+            message = {'error': True, 'message': f"Couldn't validate Google headers - {headers}"}
+            log.error(message['message'])
+            return message
+
+        try:
+            post_data = decompress(data, serialize='pickle')
+            result = worker.run_task(**post_data)
+            return {'error': False, 'result': result}
+
+        except Exception as error: #pylint: disable=broad-exception-caught
+            message = f'Worker {cls.worker_id} error: {str(error)}'
+            log.error('Worker %s error: %s', cls.worker_id, traceback.format_exc())
+            return {'error': True, 'message': message}

everysk/sdk/__init__.py

@@ -0,0 +1,23 @@
+###############################################################################
+#
+# (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.core.string import import_from_string
+
+
+###############################################################################
+#   Private Functions Implementation
+###############################################################################
+def __getattr__(_name: str):
+    from everysk.config import settings # pylint: disable=import-outside-toplevel
+    modules = settings.EVERYSK_SDK_MODULES_PATH
+
+    if _name in modules:
+        return import_from_string(modules[_name])
+
+    raise AttributeError(f"cannot import name '{_name}' from everysk.sdk")

everysk/sdk/base.py

@@ -0,0 +1,98 @@
+###############################################################################
+#
+# (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 inspect
+from typing import Any
+
+from everysk.core.exceptions import HttpError, SDKError
+from everysk.core.http import HttpSDKPOSTConnection, httpx
+from everysk.core.object import BaseDict, BaseObject
+from everysk.core.string import import_from_string
+
+
+###############################################################################
+#   Public Functions Implementation
+###############################################################################
+def handler_input_args(input_args: Any) -> Any:
+    """
+    This function handles the input arguments and returns the dictionary.
+
+    Args:
+        input_args (Any): The input arguments to be handled.
+
+    Returns:
+        Any: The parsed object.
+    """
+    ret: Any = input_args
+    if isinstance(input_args, dict):
+        ret = BaseDict()
+        for key, value in input_args.items():
+            ret[key] = handler_input_args(value)
+
+    elif isinstance(input_args, list):
+        ret = type(input_args)()
+        for item in input_args:
+            ret.append(handler_input_args(item))
+
+    return ret
+
+
+###############################################################################
+#   BaseSDK Class Implementation
+###############################################################################
+class BaseSDK(BaseObject):
+    """
+    A base class for SDK classes.
+
+    This class provides a base implementation for SDK classes.
+    """
+
+    @classmethod
+    def get_response(cls, **kwargs: dict) -> Any:
+        """
+        Get a response from an SDK method.
+
+        This method sends an HTTP POST request to a remote service and returns the response as a dictionary.
+
+        Args:
+            **kwargs (dict): Keyword arguments used to configure the HTTP request and SDK behavior.
+
+        Keyword Args:
+            class_name (str, optional): The name of the SDK class making the request. Defaults to the class name of the calling class.
+            method_name (str, optional): The name of the SDK method making the request. Defaults to the name of the calling function.
+            self_obj (object, optional): An instance of the calling SDK class, if applicable. Defaults to None.
+            params (dict, optional): Additional parameters to include in the HTTP request. Defaults to an empty dictionary.
+
+        Returns:
+            Any: The response from the remote service.
+
+        Raises:
+            SDKError: If there is an issue with the SDK operation.
+        """
+        # Set default values for keyword arguments if not provided
+        kwargs.setdefault('class_name', cls.__name__)
+        kwargs.setdefault('method_name', inspect.stack()[1].function)
+        kwargs.setdefault('self_obj', None)
+        kwargs.setdefault('params', {})
+
+        try:
+            response: httpx.Response = HttpSDKPOSTConnection(**kwargs).get_response_decode()
+        except HttpError as error:
+            raise SDKError(error.msg) from error
+
+        if (
+            response
+            and isinstance(response, (dict, BaseDict))
+            and 'error_message' in response
+            and 'error_module' in response
+        ):
+            error_module = import_from_string(response['error_module'])
+            raise error_module(response['error_message'])
+
+        return response