everysk-lib 1.10.2__cp312-cp312-win_amd64.whl

everysk/core/cloud_function/main.py

@@ -0,0 +1,78 @@
+###############################################################################
+#
+# (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.
+#
+###############################################################################
+# Remember that this code will be running on Cloud Functions environment
+# then not all modules can be used/imported.
+from logging import getLogger, INFO, StreamHandler, Formatter
+from os import getenv
+from sys import stdout
+from redis import Redis
+
+## Create a Logger object
+log = getLogger('firestore-cached-document-write')
+log.setLevel(INFO)
+log.propagate = False # Don't pass message to others loggers
+handler = StreamHandler(stdout)
+handler.setLevel(INFO)
+handler.setFormatter(Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+log.addHandler(handler)
+
+
+class RedisClient:
+
+    ## Private attributes
+    _connection: Redis = None
+
+    @property
+    def connection(self) -> Redis:
+        """
+        We use this property to check if Redis is online
+        then returning the working connection.
+        """
+        try:
+            self._connection.ping()
+        except Exception: # pylint: disable=broad-exception-caught
+            # Create a new connection
+            self._connection = Redis(
+                host=getenv('REDIS_HOST'),
+                port=int(getenv('REDIS_PORT'))
+            )
+
+        return self._connection
+
+    def delete(self, key):
+        return self.connection.delete(key)
+
+
+def firestore_cached_document_write(event: dict, context: type) -> None: # pylint: disable=unused-argument
+    """
+    Triggered by a change to a Firestore document.
+
+    Args:
+        event (dict): Event payload -> {'oldValue': {}, 'updateMask': {}, 'value': {}}.
+        context (google.cloud.functions.Context): Metadata for the event.
+    """
+    old_document = event.get('oldValue', {})
+    new_document = event.get('value', {})
+    client = RedisClient()
+
+    if new_document:
+        # Create or Update was triggered
+        doc = new_document
+    else:
+        # Delete was triggered
+        doc = old_document
+
+    key = doc.get('fields', {}).get('redis_key', None)
+    # We just need to delete the key as the original process
+    # will take care of creating it if necessary.
+    if key is not None:
+        key = key['stringValue']
+        client.delete(key)
+        log.info('Redis host: %s - %s', getenv('REDIS_HOST'), key)

everysk/core/cloud_function/tests.py

@@ -0,0 +1,86 @@
+###############################################################################
+#
+# (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 os
+from everysk.core.object import BaseObject
+from everysk.core.cloud_function import main
+from everysk.core.unittests import TestCase, mock
+
+
+class CloudFunctionTestCase(TestCase):
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.old_redis_host = os.environ.get('REDIS_HOST', None)
+        cls.old_redis_port = os.environ.get('REDIS_PORT', None)
+        os.environ['REDIS_HOST'] = '127.0.0.1'
+        os.environ['REDIS_PORT'] = '6379'
+        cls.client = main.RedisClient()
+        cls.redis_key = 'cloud-function-unit-test-redis-key'
+
+    def setUp(self) -> None:
+        self.client.connection.set(self.redis_key, 1, 1)
+        self.context = BaseObject(resource='/project/collection/document')
+        self.document = {
+            'createTime': '2023-01-01T00:00:00+00:00',
+            'fields': {
+                'redis_key': {'stringValue': self.redis_key}
+            },
+            'name': '/project/collection/document',
+            'updateTime': '2023-01-01T00:00:00+00:00'
+        }
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        if cls.old_redis_host is not None:
+            os.environ['REDIS_HOST'] = cls.old_redis_host
+        else:
+            del os.environ['REDIS_HOST']
+
+        if cls.old_redis_port is not None:
+            os.environ['REDIS_PORT'] = cls.old_redis_port
+        else:
+            del os.environ['REDIS_PORT']
+
+    def test_redis_connection(self):
+        client = main.RedisClient()
+        self.assertIsInstance(client.connection, main.Redis)
+
+    def test_redis_delete(self):
+        self.assertEqual(self.client.connection.get(self.redis_key), b'1')
+        self.client.delete(self.redis_key)
+        self.assertIsNone(self.client.connection.get(self.redis_key))
+
+    @mock.patch.object(main.log, 'info')
+    def test_firestore_create(self, info: mock.MagicMock):
+        event = {'oldValue': {}, 'updateMask': {}, 'value': self.document}
+        main.firestore_cached_document_write(event, self.context)
+        info.assert_called_once_with('Redis host: %s - %s', os.environ['REDIS_HOST'], self.redis_key)
+        self.assertIsNone(self.client.connection.get(self.redis_key))
+
+    @mock.patch.object(main.log, 'info')
+    def test_firestore_delete(self, info: mock.MagicMock):
+        event = {'oldValue': self.document, 'updateMask': {}, 'value': {}}
+        main.firestore_cached_document_write(event, self.context)
+        info.assert_called_once_with('Redis host: %s - %s', os.environ['REDIS_HOST'], self.redis_key)
+        self.assertIsNone(self.client.connection.get(self.redis_key))
+
+    @mock.patch.object(main.log, 'info')
+    def test_firestore_update(self, info: mock.MagicMock):
+        event = {'oldValue': self.document, 'updateMask': {}, 'value': self.document}
+        main.firestore_cached_document_write(event, self.context)
+        info.assert_called_once_with('Redis host: %s - %s', os.environ['REDIS_HOST'], self.redis_key)
+        self.assertIsNone(self.client.connection.get(self.redis_key))
+
+    @mock.patch.object(main.log, 'info')
+    def test_firestore_other(self, info: mock.MagicMock):
+        event = {'oldValue': {}, 'updateMask': {}, 'value': {}}
+        main.firestore_cached_document_write(event, self.context)
+        info.assert_not_called()
+        self.assertEqual(self.client.connection.get(self.redis_key), b'1')

everysk/core/compress.py

@@ -0,0 +1,245 @@
+###############################################################################
+#
+# (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.
+#
+###############################################################################
+
+__all__ = ['compress', 'decompress']
+
+import gzip
+import zlib
+import io
+import os
+import zipfile
+import base64
+import fnmatch
+from typing import Any
+
+from everysk.core.log import Logger
+from everysk.core.serialize import dumps, loads
+
+
+log = Logger('everysk-lib-compress')
+
+
+###############################################################################
+#   Private Functions Implementation
+###############################################################################
+def compress_json(obj: Any) -> str:
+    """
+    This function first serializes the input object into a JSON string using the dumps function.
+    Then it compresses the JSON string using zlib compression.
+    The output is a bytes object which may contain non-printable characters due to compression
+
+    Args:
+        obj (Any): The JSON-serializable object to compress.
+
+    Returns:
+        str: The compressed string representation of the JSON-serialized object.
+
+    Example:
+        >>> data = {'key': 'value'}
+        >>> compressed_data = compress_json(data)
+        >>> print(compressed_data)
+        >>> b'x\x9c\xcbH\xcd\xc9\xc9W(....)' # Example of the compressed data
+    """
+    log.deprecated("compress_json is deprecated. Use compress(obj, serialize='json') instead.")
+    return compress(obj, serialize='json')
+
+def decompress_json(data: str, convert_str_to_date: bool = False) -> Any: # pylint: disable=unused-argument
+    """
+    Decompress data with zlib and transform to an obj with loads function.
+    The input data should be a zlib-compressed string.
+    The returned object may be any valid JSON-serializable Python object
+
+    Args:
+        data (str): the zlib-compressed string to decompress and deserialized data.
+        convert_str_to_date (bool, optional): Enable conversion of str to Date and Datetime. Default is True.
+
+    Returns:
+        Any: The Python object reconstructed from the decompressed and deserialized.
+
+    Example:
+        >>> from everysk.core.compress import decompress_json
+        >>> compressed_data = b'x\x9c\xabV\xcaN\xadT\xb2RP*K\xcc)MU\xaa\x05\x00+\xaf\x05A'
+        >>> decompressed_data = decompress_json(compressed_data)
+        >>> print(decompressed_data)
+        >>> {'key': 'value'} # Example of the decompressed data'
+    """
+    log.deprecated("decompress_json is deprecated. Use decompress(obj, serialize='json') instead.")
+    return decompress(data, serialize='json')
+
+def compress_pickle(obj: Any) -> str:
+    """
+    Convert obj to string with pickle dumps then uses zlib to compress it.
+    The output is a bytes object which may contain non-printable characters due to compression.
+
+    Args:
+        obj (Any): The Python object to compress.
+
+    Returns:
+        str: The compressed string representation of the serialized object.
+
+    Example:
+        >>> data = {'key': 'value'}
+        >>> compressed_data = compress_pickle(data)
+        >>> print(compressed_data)
+        >>> b'x\x9c\xabV*I,.Q(...)'  # Example compressed string output
+    """
+    log.deprecated("compress_pickle is deprecated. Use compress(obj, serialize='pickle') instead.")
+    return compress(obj, serialize='pickle')
+
+def decompress_pickle(data: str) -> Any:
+    """
+    Decompress data with zlib and transform to a obj with pickle loads.
+    The input data should be a zlib-compressed string generated from a pickled Python object.
+
+    Args:
+        data (str): The zlib-compressed string to decompress and deserialize.
+
+    Returns:
+        Any: The Python object reconstructed from the decompressed and deserialized data.
+
+    Example:
+        >>> compressed_data = b'x\x9c\xabV\xcaN\xadT\xb2RP*K\xcc)MU\xaa\x05\x00+\xaf\x05A' # Example compressed data
+        >>> decompressed_data = decompress_pickle(compressed_data)
+        >>> print(decompressed_data)
+        >>> {'key': 'value'}  # Example decompressed object output
+    """
+    log.deprecated("decompress_pickle is deprecated. Use decompress(obj, serialize='pickle') instead.")
+    return decompress(data, serialize='pickle')
+
+def zip_directory_to_str(path_list: str | list, path_name_list: str | list, ignore_files: list = None, ignore_roots: list = None) -> str:
+    """
+    This function takes a directory path as input and creates a zip file in memory.
+
+    Args:
+        path_list (str | list): The path to the directory to zip, it can be a list of paths.
+        path_name_list (str | list): The name of the root folder inside the zip file, it can be a list of path names.
+        ignore_files (list, optional): A list of file names to ignore when zipping the directory.
+        ignore_roots (list, optional): A list of patterns to ignore when zipping the directory.
+
+    Returns:
+        str: The base64 encoded string representation of the zip file.
+
+    Raises:
+        ValueError: If the length of path_list and path_name_list is not the same.
+
+    Example:
+        >>> zip_directory_to_str('path/to/directory', 'root_folder_name')
+        >>> zip_directory_to_str('path/to/directory', 'root_folder_name', ['config.json'], ['**/log', '**/temp/**'])
+
+        Below is an example of using a list of paths and path names:
+        >>> zip_directory_to_str(['path/to/directory1', 'path/to/directory2'], ['root_folder_name1', 'root_folder_name2'], ['config.json'], ['**/log', '**/temp/**'])
+    """
+    # Create a BytesIO object to store the zip file
+    memory_zip = io.BytesIO()
+
+    if isinstance(path_list, str):
+        path_list = [path_list]
+
+    if isinstance(path_name_list, str):
+        path_name_list = [path_name_list]
+
+    if len(path_list) != len(path_name_list):
+        raise ValueError("The length of path_list and path_name_list should be the same.")
+
+    # Create a ZipFile object with the memory buffer as its destination
+    with zipfile.ZipFile(memory_zip, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        for path, path_name in zip(path_list, path_name_list):
+            for root, _, files in os.walk(path):
+                # Check if the current root matches any of the ignore_roots patterns
+                if ignore_roots and any(fnmatch.fnmatch(root, pattern) for pattern in ignore_roots):
+                    continue
+                for file in files:
+                    # Ignore files if specified
+                    if ignore_files and file in ignore_files:
+                        continue
+                    file_path = os.path.join(root, file)
+                    # Compute the relative path and add the path_name as the root folder
+                    relative_path = os.path.relpath(file_path, path)
+                    zip_file.write(file_path, os.path.join(path_name, relative_path))
+
+    # We need to adjust the cursor of the BytesIO object to the start after writing
+    memory_zip.seek(0)
+
+    # Return the base64 encoded string representation of the zip file
+    return base64.b64encode(memory_zip.getvalue()).decode('utf-8')
+
+###############################################################################
+#   Public Functions Implementation
+###############################################################################
+def compress(obj: Any, protocol: str = 'zlib', serialize: str | None = 'pickle', use_undefined: bool | None = True, add_class_path: bool | None = None) -> bytes:
+    """
+    Compress an object using either zlib or gzip compression.
+    If serialize is set, the object is serialized using the specified serialization format before compression.
+    Supported options for serialization are JSON or Pickle.
+
+    Args:
+        obj (Any): The Python object to compress
+        protocol (str, optional): The serialization protocol to use. Default is 'zlib'. Options are 'zlib' and 'gzip'.
+        serialize (str, optional): The serialization format to use. Default is 'pickle'. Options are 'json', 'pickle' and None.
+        use_undefined (bool, optional): If True, undefined values are included in the serialization. Default is True.
+        add_class_path (bool, optional): If True, the class path is included in the serialization. Default is None.
+
+    Returns:
+        bytes: The compressed string representation of the serialized object.
+
+    Example:
+        >>> data = {'key': 'value'}
+        >>> compress(data)
+        >>> b'x\x9c\xabV*I,.Q(...)'  # Example compressed string output
+    """
+    if protocol == 'zlib':
+        compress_fn = zlib.compress
+    elif protocol == 'gzip':
+        compress_fn = gzip.compress
+    else:
+        raise ValueError(f"Unsupported compression protocol '{protocol}'. Use 'zlib' or 'gzip'.")
+
+    result = obj
+    if serialize:
+        result = dumps(obj, protocol=serialize, use_undefined=use_undefined, add_class_path=add_class_path)
+
+    if isinstance(result, str):
+        result = result.encode('utf-8')
+
+    return compress_fn(result)
+
+def decompress(data: bytes, protocol: str = 'zlib', serialize: str | None = 'pickle', use_undefined: bool | None = True, instantiate_object: bool | None = True) -> Any:
+    """
+    Decompress data using either zlib or gzip compression.
+    If serialize is set, the result from decompress is serialized using the specified serialization converting it to a python object.
+    Supported options for serialization are JSON or Pickle.
+
+    Args:
+        data (bytes): The compressed data to decompress.
+        protocol (str, optional): The serialization protocol to use. Default is 'zlib'. Options are 'zlib' and 'gzip'.
+        serialize (str, optional): The serialization format to use. Default is 'pickle'. Options are 'json', 'pickle' and None.
+        use_undefined (bool, optional): If True, undefined values are included in the serialization. Default is True.
+        instantiate_object (bool, optional): If True, the object is instantiated. Default is True.
+
+    Returns:
+        Any: If serialize is set returns a Python object otherwise a bytes object.
+
+    Example:
+        >>> compressed_data = b'x\x9c\xabV\xcaN\xadT\xb2RP*K\xcc)MU\xaa\x05\x00+\xaf\x05A' # Example of compressed data
+        >>> decompress(compressed_data)
+        >>> {'key': 'value'}
+    """
+    if protocol == 'zlib':
+        decompress_fn = zlib.decompress
+    elif protocol == 'gzip':
+        decompress_fn = gzip.decompress
+    else:
+        raise ValueError(f"Unsupported decompression protocol '{protocol}'. Use 'zlib' or 'gzip'.")
+
+    result = decompress_fn(data)
+    if serialize:
+        result = loads(result, protocol=serialize, use_undefined=use_undefined, instantiate_object=instantiate_object)
+
+    return result

everysk/core/datetime/__init__.py

@@ -0,0 +1,12 @@
+###############################################################################
+#
+# (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.datetime.datetime import DateTime, timezone, ZoneInfo
+from everysk.core.datetime.date import Date
+from everysk.core.datetime.date_mixin import timedelta

everysk/core/datetime/calendar.py

@@ -0,0 +1,144 @@
+###############################################################################
+#
+# (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 functools import cache
+
+import holidays
+from holidays.countries import BR
+
+from everysk.core.datetime import Date
+
+
+class BRHolidays(BR):
+    """
+    Subclass of BR representing holidays specific to Brazil and also provides further functionality
+    """
+
+    def _populate(self, year: int) -> None:
+        """
+        Populate holidays specific to Brazil for the given year.
+
+        Args:
+            year (int): The year for which holidays are to be populated.
+
+        Example:
+            >>> from everysk.core.datetime.calendar import BRHolidays
+            >>> br_holidays = BRHolidays()
+            >>> br_holidays._populate(2022)
+            >>> print(br_holidays)
+            {
+                datetime.date(2022, 1, 1): 'Confraternização Universal',
+                datetime.date(2022, 4, 15): 'Sexta-feira Santa',
+                ...
+            }
+        """
+        super()._populate(year)
+
+        # We need to check individually for these holidays
+        try:
+            self.pop_named('Início da Quaresma')
+        except KeyError:
+            pass
+
+        try:
+            self.pop_named('Dia do Servidor Público')
+        except KeyError:
+            pass
+
+        try:
+            self.pop_named('Véspera de Natal')
+        except KeyError:
+            pass
+
+        try:
+            self.pop_named('Véspera de Ano-Novo')
+        except KeyError:
+            pass
+
+
+class ANBIMA(BRHolidays):
+    pass
+
+
+class BVMF(BRHolidays):
+    """
+    Subclass of BRHolidays representing holidays specific to the BVMF calendar.
+    """
+    def _populate(self, year: int) -> None:
+        """
+        _summary_
+
+        Args:
+            year (int): The year for the holidays to be populated
+
+        Example:
+            Display the holidays for the year of 2022
+
+            >>> from everysk.core.datetime.calendar import BVMF
+            >>> bvmf_holidays = BVMF()
+            >>> bvmf_holidays._populate(2022)
+            >>> print(bvmf_holidays)
+            {
+                datetime.date(2022, 1, 1): 'Confraternização Universal',
+                datetime.date(2022, 4, 15): 'Sexta-feira Santa',
+                ...
+            }
+        """
+        super()._populate(year)
+
+        if year < 2022:
+            self[Date(year, 1, 25)] = 'Aniversário de São Paulo'
+            self[Date(year, 11, 20)] = 'Dia da Consciência Negra'
+
+
+def get_holidays(calendar: str, years: list = range(2000, 2100)) -> dict:
+    """
+    Uses the holidays library (https://pypi.org/project/holidays/) to retrieve a list of holidays for a specific country
+
+    It also uses a range of years, if more specification needed
+
+    Args:
+        calendar (str): Two digit country symbol.
+        years (list, optional): List of int years. Ex: [2021, 2022]. Defaults to [2000, ..., 2099].
+
+    Example:
+        Getting holidays for Brazil (BVMF calendar) for the years 2021 and 2022.
+
+        >>> from everysk.core.datetime.calendar import get_holidays
+        >>> brazil_holidays = get_holidays('BR', years=[2021, 2022])
+        >>> print(brazil_holidays)
+        {
+            datetime.date(2021, 1, 1) : 'Confraternização Universal',
+            datetime.date(2021, 4, 2) : 'Sexta-feira Santa',
+            ...
+        }
+    """
+    return _get_holidays(calendar=calendar, years=tuple(years))
+
+
+@cache
+def _get_holidays(calendar: str, years: tuple[int]) -> dict:
+    """
+    Cacheable version of get_holidays.
+    """
+    holidays.BVMF = BVMF
+    holidays.ANBIMA = ANBIMA
+    holidays.BRHolidays = BRHolidays
+
+    # We need to remove some holidays for the BR calendar so we change it
+    if calendar == 'BR':
+        calendar = 'BRHolidays'
+
+    # Every country has public holidays
+    # Brazil has optional holidays as well
+    categories = ['public']
+    if calendar in {'BRHolidays', 'BVMF', 'ANBIMA'}:
+        categories.append('optional')
+
+    return {Date(dt.year, dt.month, dt.day): name for dt, name in holidays.country_holidays(calendar, years=years, categories=categories).items()}