flowtask 5.8.4__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

flowtask/interfaces/locale.py

@@ -0,0 +1,40 @@
+from typing import Optional
+from abc import ABC
+import logging
+import locale
+
+
+class LocaleSupport(ABC):
+    """LocaleSupport.
+
+    Adding Support for Encoding and Locale to every Component in FlowTask.
+    """
+
+    encoding: str = "UTF-8"
+    _locale: Optional[str] = None
+
+    def __init__(self, *args, **kwargs):
+        self.encoding = kwargs.pop('encoding', "UTF-8")
+        self._locale = kwargs.pop('l18n', None)
+        # Localization
+        if self._locale is None:
+            newloc = (locale.getlocale())[0]
+            self._locale = f"{newloc}.{self.encoding}"
+        else:
+            if self.encoding not in self._locale:
+                self._locale = f"{self._locale}.{self.encoding}"
+        try:
+            # avoid errors on unsupported locales
+            locale.setlocale(locale.LC_TIME, self._locale)
+        except (RuntimeError, NameError, locale.Error) as err:
+            logging.warning(
+                f"Error on Locale Support: {err}"
+            )
+            newloc = (locale.getlocale())[0]
+            self._locale = f"{newloc}.UTF-8"
+            locale.setlocale(locale.LC_TIME, self._locale)
+        # Call super only if there’s a next class in the MRO
+        try:
+            super().__init__(*args, **kwargs)
+        except TypeError:
+            super().__init__()

flowtask/interfaces/log.py

@@ -0,0 +1,75 @@
+from abc import ABC
+from enum import Enum
+import traceback
+from navconfig.logging import logging
+from ..utils import cPrint
+from ..exceptions import ComponentError
+
+### TODO: Adding functions for Raising Errors.
+class SkipErrors(Enum):
+    SKIP = "skip"
+    LOG = "log_only"
+    ENFORCE = None
+
+    def __str__(self):
+        return {
+            SkipErrors.SKIP: "skip",
+            SkipErrors.LOG: "Log Errors",
+            SkipErrors.ENFORCE: "Enforce",
+        }[self]
+
+class LogSupport(ABC):
+    """LogSupport.
+
+    Adding Logging support to every FlowTask Component.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._name = kwargs.get('name', self.__class__.__name__)
+        self.skipError: SkipErrors = SkipErrors.ENFORCE
+        # logging object
+        self._logger = logging.getLogger(
+            f"FlowTask.Component.{self._name}"
+        )
+        # Debugging
+        self._debug: bool = kwargs.get('debug', False)
+        if self._debug:
+            self._logger.setLevel(logging.DEBUG)
+        super().__init__(*args, **kwargs)
+
+    def log(self, message) -> None:
+        self._logger.info(message)
+        if self._debug is True:
+            cPrint(message, level="INFO")
+
+    def debug(self, message):
+        self._logger.debug(message)
+        if self._debug is True:
+            cPrint(message, level="DEBUG")
+
+    def warning(self, message):
+        self._logger.warning(message)
+        if self._debug is True:
+            cPrint(message, level="WARN")
+
+    def exception(self, message):
+        self._logger.exception(message, stack_info=True)
+        if self._debug is True:
+            cPrint(message, level="CRITICAL")
+
+    def echo(self, message: str, level: str = "INFO") -> None:
+        cPrint(message, level=level)
+
+    def error(
+        self,
+        message: str,
+        exc: BaseException,
+        status: int = 400,
+        stacktrace: bool = False,
+    ):
+        payload = None
+        if stacktrace is True:
+            payload = traceback.format_exc()
+        raise ComponentError(
+            f"{message}, error={exc}", status=status, stacktrace=payload
+        ) from exc

flowtask/interfaces/mask.py

@@ -0,0 +1,143 @@
+from abc import ABC
+from typing import ParamSpec, Any
+from pathlib import Path, PurePath
+from navconfig.logging import logging
+from ..utils import SafeDict, fnExecutor
+
+
+P = ParamSpec("P")
+
+
+class MaskSupport(ABC):
+    """MaskSupport.
+
+    Processing Masks Support.
+    """
+    def __init__(
+        self,
+        *args: P.args,
+        **kwargs: P.kwargs
+    ):
+        self._mask = {}  # masks for function replacing
+        masks = kwargs.pop('_masks', {})
+        self.logger = logging.getLogger('Flowtask.Mask')
+        # filling Masks:
+        if "masks" in kwargs:
+            self._mask = kwargs.pop('masks')
+            object.__setattr__(self, "masks", self._mask)
+        for mask, replace in masks.items():
+            self._mask[mask] = replace  # override component's masks
+        try:
+            super().__init__(*args, **kwargs)
+        except TypeError:
+            super().__init__()
+
+    def _mask_processing(self, variables: dict) -> None:
+        try:
+            for mask, replace in self._mask.items():
+                # first: making replacement of masks based on vars:
+                try:
+                    if mask in variables:
+                        value = variables[mask]
+                    else:
+                        value = replace.format(**variables)
+                except Exception:
+                    value = replace
+                value = fnExecutor(value)
+                self.logger.notice(
+                    f":: Set Mask {mask} == {value!s}"
+                )
+                self._mask[mask] = value
+        except Exception as err:
+            self.logger.warning(
+                f"Mask Error: {err}"
+            )
+
+    def mask_replacement(self, obj: Any):
+        """mask_replacement.
+
+        Replacing occurrences of Masks into an String.
+        Args:
+            obj (Any): Any kind of object.
+
+        Returns:
+            Any: Object with replaced masks.
+        """
+        for mask, replace in self._mask.items():
+            if mask in self._variables:
+                value = self._variables[mask]
+                # Using SafeDict instead direct replacement:
+                value = str(obj).format_map(SafeDict(**self._variables))
+            else:
+                if str(obj) == mask and mask.startswith("#"):
+                    # full replacement of the mask
+                    obj = replace
+                    return obj
+                else:
+                    try:
+                        if str(obj) == mask and mask.startswith("{"):
+                            value = str(obj).replace(mask, str(replace))
+                        elif mask in str(obj) and mask.startswith("{"):
+                            try:
+                                value = str(obj).replace(mask, str(replace))
+                            except (ValueError, TypeError) as exc:
+                                # remove the "{" and "}" from the mask
+                                mask = mask[1:-1]
+                                value = str(obj).format_map(
+                                    SafeDict({mask: replace})
+                                )
+                        else:
+                            value = str(obj).format_map(
+                                SafeDict({mask: replace})
+                            )
+                    except (ValueError, TypeError):
+                        value = str(obj).replace(mask, str(replace))
+            if isinstance(obj, PurePath):
+                obj = Path(value).resolve()
+            else:
+                obj = value
+        return obj
+
+    def mask_replacement_recursively(self, obj: Any):
+        """
+        This function replaces all occurrences of "{key}" in the obj structure
+        with the corresponding value from the replacements dictionary, recursively.
+
+        Args:
+            obj: an object to process.
+
+        Returns:
+            The modified obj structure with curly brace replacements.
+        """
+
+        if isinstance(obj, dict):
+            # If it's a dictionary, iterate through each key-value pair
+            for key, value in obj.copy().items():
+                # Recursively replace in the key and value
+                obj[key] = self.mask_replacement_recursively(value)
+
+                # Check if the key itself has curly braces
+                if isinstance(key, str):
+                    # Use f-string for formatted key
+                    new_key = self.mask_replacement(key)
+
+                    if new_key != key:
+                        obj.pop(key)  # Remove old key and add formatted one
+                        obj[new_key] = value  # Add key-value pair with formatted key
+
+        elif isinstance(obj, list):
+            # If it's a list, iterate through each element and replace recursively
+            for idx, value in enumerate(obj):
+                obj[idx] = self.mask_replacement_recursively(value)
+
+        elif isinstance(obj, str):
+            # If it's a string, use f-string formatting to replace
+            return self.mask_replacement(obj)
+
+        return obj
+
+    def mask_start(self, **kwargs):
+        # Usable by Hooks
+        self._masks: dict = kwargs.pop("masks", {})
+        self._variables = kwargs.pop("variables", {})
+        self._mask_processing(variables=self._variables)

flowtask/interfaces/notification.py

@@ -0,0 +1,154 @@
+"""
+Interface for sending messages using Notify.
+"""
+import os
+import asyncio
+from pathlib import Path, PurePath
+from navconfig.logging import logging
+from notify import Notify
+from notify.providers.email import Email
+from notify.models import (
+    Actor,
+    Chat,
+    Channel,
+    TeamsChannel,
+    TeamsCard
+)
+from notify.conf import MS_TEAMS_DEFAULT_TEAMS_ID
+from flowtask.conf import (
+    EVENT_CHAT_ID,
+    EVENT_CHAT_BOT,
+    DEFAULT_RECIPIENT,
+    EMAIL_USERNAME,
+    EMAIL_PASSWORD,
+    EMAIL_PORT,
+    EMAIL_HOST,
+    SLACK_DEFAULT_CHANNEL,
+    SLACK_DEFAULT_CHANNEL_NAME,
+    MS_TEAMS_NAVIGATOR_CHANNEL,
+    MS_TEAMS_NAVIGATOR_CHANNEL_ID,
+)
+from .mask import MaskSupport
+
+
+class Notification(MaskSupport):
+    def __init__(self, *args, **kwargs):
+        super(Notification, self).__init__(*args, **kwargs)
+        self.provider: str = kwargs.pop("type", "dummy")
+        self.list_attachment: list = []
+        self.account: str = self.set_account(
+            kwargs.pop("account", {})
+        )
+        # recipient:
+        self._recipients = kwargs.pop("recipients", [])
+        self._channel = kwargs.pop("channel", "Navigator")
+        self._channel_id = kwargs.pop("channel_id", None)
+        self._chat_id = kwargs.pop('chat_id', EVENT_CHAT_ID)
+        self._bot_token = kwargs.pop('bot_token', EVENT_CHAT_BOT)
+        self._kwargs = kwargs
+        self.message = kwargs.pop("message", {})
+        template = self.message.pop("template", None)
+        self._template = kwargs.pop("template", template)
+        self._loop = kwargs.pop(
+            "event_loop",
+            asyncio.get_event_loop()
+        )
+
+    def set_account(self, account: dict):
+        for key, default in account.items():
+            val = self.get_env_value(account[key], default=default)
+            account[key] = val
+        return account
+
+    def get_env_value(self, key, default: str = None):
+        if key is None:
+            return None
+        if val := os.getenv(key):
+            return val
+        elif val := self._environment.get(key, default):
+            return val
+        else:
+            return key
+
+    def get_notify(self, **kwargs):
+        recipient = Actor(**DEFAULT_RECIPIENT)
+        if self.provider == "telegram":
+            recipient = Chat(**{"chat_id": self._chat_id, "chat_name": self._channel})
+            # send notifications to Telegram bot
+            args = {
+                "bot_token": self._bot_token,
+                "loop": asyncio.get_event_loop(),
+                **kwargs,
+            }
+            provider = Notify("telegram", **args)
+        elif self.provider == "outlook":
+            args = {"use_credentials": True, "loop": asyncio.get_event_loop(), **kwargs}
+            provider = Notify("outlook", **args)
+        elif self.provider == "slack":
+            _id = self._channel_id if self._channel_id else SLACK_DEFAULT_CHANNEL
+            name = self._channel if self._channel else SLACK_DEFAULT_CHANNEL_NAME
+            recipient = Channel(channel_id=_id, channel_name=name)
+            provider = Notify("slack", **kwargs)
+        elif self.provider == "email":
+            if not self.account:
+                account = {
+                    "host": EMAIL_HOST,
+                    "port": EMAIL_PORT,
+                    "username": EMAIL_USERNAME,
+                    "password": EMAIL_PASSWORD,
+                }
+            else:
+                account = self.account
+            account = {**account, **kwargs}
+            if not self._recipients:
+                recipient = Actor(**DEFAULT_RECIPIENT)
+            else:
+                recipient = [Actor(**user) for user in self._recipients]
+            provider = Email(debug=True, **account)
+        elif self.provider == "teams":
+            _id = (
+                self._channel_id if self._channel_id else MS_TEAMS_NAVIGATOR_CHANNEL_ID
+            )
+            name = self._channel if self._channel else MS_TEAMS_NAVIGATOR_CHANNEL
+            args = {"as_user": True, "loop": asyncio.get_event_loop(), **kwargs}
+            recipient = TeamsChannel(
+                name=name, team_id=MS_TEAMS_DEFAULT_TEAMS_ID, channel_id=_id
+            )
+            provider = Notify("teams", **args)
+        else:
+            # Any other Notify Provider:
+            if not self._recipient:
+                recipient = Actor(**DEFAULT_RECIPIENT)
+            else:
+                recipient = [Actor(**user) for user in self._recipients]
+            provider = Notify(self.provider, **kwargs)
+        logging.debug(f"Created Notify Component {provider}")
+        return [provider, recipient]
+
+    def get_attachment_files(self, result: list) -> list:
+        if result is None:
+            return []
+        elif isinstance(result, str):
+            result = [result]
+        files = []
+        for part in result:
+            if isinstance(part, str):
+                file = Path(part.strip("'"))
+                if file.exists():
+                    files.append(file)
+            elif isinstance(part, PurePath):
+                if file.exists():
+                    files.append(file)
+        return files
+
+    def get_message(self, message: str):
+        if self.provider in ("email", "gmail", "outlook"):
+            args = {"subject": message, **self.message}
+        elif self.provider == "teams":
+            msg = TeamsCard(text=message, summary="Task Summary")
+            args = {"message": msg, **self.message}
+        elif self.provider in ("slack", "telegram"):
+            args = {"message": message, **self.message}
+        else:
+            args = {"message": message, **self.message}
+        return args