flowtask 5.8.4__cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

flowtask/extensions/__init__.py

@@ -0,0 +1,3 @@
+from .abstract import BaseExtension
+
+__all__ = ("BaseExtension",)

flowtask/extensions/abstract.py

@@ -0,0 +1,82 @@
+"""BaseExtension is a Helper to build Pluggable extensions for FlowTask."""
+import sys
+from typing import Optional
+from collections.abc import Callable
+from abc import ABC
+from navconfig.logging import logging
+from navigator.types import WebApp
+from ..exceptions import TaskException
+
+if sys.version_info < (3, 10):
+    from typing_extensions import ParamSpec
+else:
+    from typing import ParamSpec
+P = ParamSpec("P")
+
+
+class ExtensionError(TaskException):
+    """Useful for raise errors from Extensions."""
+
+
+class BaseExtension(ABC):
+    """BaseExtension.
+
+    Description: Base Class for all FlowTask Extensions.
+    """
+
+    app: WebApp
+
+    # Signal for any startup method on application.
+    on_startup: Optional[Callable] = None
+
+    # Signal for any shutdown process (will registered into App).
+    on_shutdown: Optional[Callable] = None
+
+    # Signal for any cleanup process (will registered into App).
+    on_cleanup: Optional[Callable] = None
+
+    # adding custom middlewares to app (if needed)
+    middleware: Optional[Callable] = None
+
+    def __init__(self, *args: P.args, **kwargs: P.kwargs) -> None:
+        ### added config support
+        self._args = args
+        self._kwargs = kwargs
+        ## name of the extension:
+        self.__name__: str = self.__class__.__name__
+        ### logging
+        self.logger = logging.getLogger(f"FlowTask.ext.{self.__name__}")
+
+    def setup(self, app: WebApp) -> WebApp:
+        if hasattr(app, "get_app"):  # migrate to BaseApplication (on types)
+            self.app = app.get_app()
+        elif isinstance(app, WebApp):
+            self.app = app  # register the app into the Extension
+        else:
+            raise TypeError(f"Invalid type for aiohttp Application: {app}:{type(app)}")
+        self.logger.debug(f":::: FlowTask Extension {self.__name__} Loaded ::::")
+        # add a middleware to the app
+        if callable(self.middleware):
+            try:
+                mdl = self.app.middlewares
+                # add the middleware
+                mdl.append(self.middleware)
+            except Exception as err:
+                self.logger.exception(
+                    f"Error loading Extension Middleware {self.__name__} init: {err!s}"
+                )
+                raise ExtensionError(
+                    f"Error loading Extension Middleware {self.__name__} init: {err!s}"
+                ) from err
+
+        # adding signals for startup and shutdown:
+        # startup operations over extension backend
+        if callable(self.on_startup):
+            self.app.on_startup.append(self.on_startup)
+        # cleanup operations over extension backend
+        if callable(self.on_shutdown):
+            self.app.on_shutdown.append(self.on_shutdown)
+        # cleanup operations over extension backend
+        if callable(self.on_cleanup):
+            self.app.on_cleanup.append(self.on_cleanup)
+        return self.app

flowtask/extensions/logging/__init__.py

@@ -0,0 +1,65 @@
+"""
+LoggingFacility.
+
+API For sending Logs to Backend.
+"""
+from navconfig.logging import logging
+from navigator.views import BaseView
+from ...extensions import BaseExtension
+
+
+class LoggingFacility(BaseExtension):
+    def setup(self, app):
+        super().setup(app)
+        # Logging Facility:
+        self.app.router.add_view("/api/v1/log", Logger)
+
+
+## TODO: migrate to Handler.
+class Logger(BaseView):
+    """Logging Facility."""
+
+    async def post(self):
+        data = await self.json_data()
+        print(data)
+        try:
+            message = data["message"]
+            del data["message"]
+        except KeyError:
+            return self.error(
+                request=self.request, response="Log require Message Data", state=406
+            )
+        # TODO: using jsonschema to validate JSON request
+        if "level" in data:
+            level = data["level"]
+        else:
+            level = "debug"
+        # adding tags:
+        tags = ["Navigator"]
+        if "tags" in data:
+            tags = data["tags"] + tags
+        try:
+            if level == "error":
+                logging.error(message, extra=data)
+            elif level == "debug":
+                logging.debug(message, extra=data)
+            elif level == "warning":
+                logging.warning(message, extra=data)
+            elif level == "exception":
+                logging.exception(message, extra=data)
+            else:
+                logging.info(message, extra=data)
+            headers = {"X-STATUS": "OK", "X-MESSAGE": "Logging Success"}
+            msg = {"message": message}
+            return self.json_response(response=msg, headers=headers, state=202)
+        except Exception as err:  # pylint: disable=W0703
+            headers = {
+                "X-STATUS": "Error",
+                "X-MESSAGE": "Resource Error: Logging Error",
+            }
+            msg = {
+                "state": "Failed",
+                "message": "Error: Failed Logging operation",
+                "status": 400,
+            }
+            return self.error(response=msg, exception=err, headers=headers, state=400)

flowtask/hooks/__init__.py

@@ -0,0 +1,9 @@
+"""Hooks.
+
+
+Hooks can be used to dispatch (triggering) actions or tasks when events are received.
+
+Triggers can be loaded/managed by HookService.
+
+"""
+from .service import HookService

flowtask/hooks/actions/__init__.py

@@ -0,0 +1,22 @@
+"""
+Hook Actions.
+
+Actions are the Components called by a Hook Definition.
+"""
+
+from .abstract import AbstractAction
+from .dummy import DummyAction
+from .jira import JiraTicket, JiraIssue
+from .zammad import Zammad
+from .task import Task
+from .sampledata import ProcessData
+from .sensor import ProcessSensorData
+
+__all__ = (
+    "AbstractAction",
+    "DummyAction",
+    "JiraTicket",
+    "JiraIssue",
+    "Zammad",
+    "Task",
+)

flowtask/hooks/actions/abstract.py

@@ -0,0 +1,66 @@
+from typing import Any
+from abc import ABC, abstractmethod
+from ...interfaces import LogSupport, MaskSupport, LocaleSupport
+
+
+class AbstractAction(MaskSupport, LogSupport, LocaleSupport, ABC):
+    """AbstractAction.
+
+    Action can be used to perform operations when a Hook is called.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        self._name_ = self.__class__.__name__
+        super().__init__(*args, **kwargs)
+        # program
+        self._program = kwargs.pop("program", "navigator")
+        # attributes (root-level of component arguments):
+        self._attributes: dict = kwargs.pop("attributes", {})
+        # arguments (root-level of component arguments):
+        self.arguments: dict = kwargs.pop("arguments", {})
+        # Arguments of actions::
+        try:
+            self.arguments = {**self.arguments, **kwargs}
+        except (TypeError, ValueError):
+            pass
+        # set the attributes of Action:
+        for arg, val in self.arguments.items():
+            if arg in self._attributes:
+                val = self._attributes[arg]
+            try:
+                setattr(self, arg, val)
+            except (AttributeError, TypeError) as err:
+                self._logger.warning(
+                    f"Wrong Attribute: {arg}={val}"
+                )
+                self._logger.error(err)
+        # You can define any initialization logic here, such as
+        # storing parameters that control the behavior of the action.
+        self._args = args
+        self._kwargs = kwargs
+
+    def __repr__(self) -> str:
+        return f"<Action.{self._name_}>"
+
+    @abstractmethod
+    async def open(self) -> None:
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
+    @abstractmethod
+    async def run(self, hook, *args, **kwargs) -> Any:
+        # This is where you define the behavior of the action.
+        # Since this method is asynchronous, you should use the "await"
+        # keyword to call other asynchronous functions or coroutines.
+        pass
+
+    async def __aenter__(self) -> "AbstractAction":
+        await self.open()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        # clean up anything you need to clean up
+        return await self.close()

flowtask/hooks/actions/dummy.py

@@ -0,0 +1,23 @@
+from .abstract import AbstractAction
+from ...utils import cPrint
+
+class DummyAction(AbstractAction):
+    """DummyAction.
+
+    Simply Print the Action object.
+    """
+
+    async def open(self):
+        cPrint('Opening Action on Dummy.')
+
+    async def run(self, hook, *args, **kwargs):
+        print(
+            f"Running action from hook {hook} with arguments:",
+            args,
+            self._args,
+            kwargs,
+            self._kwargs
+        )
+
+    async def close(self):
+        cPrint("Closing Action on Dummy.")

flowtask/hooks/actions/jira.py

@@ -0,0 +1,74 @@
+from jira import JIRA
+from ...conf import JIRA_API_TOKEN, JIRA_USERNAME, JIRA_INSTANCE, JIRA_PROJECT
+from .ticket import AbstractTicket
+from .abstract import AbstractAction
+
+
+class JiraTicket(AbstractTicket):
+    """Jira.
+
+    Create a Jira Ticket using a Hook.
+    """
+
+    async def open(self):
+        args = {"basic_auth": (JIRA_USERNAME, JIRA_API_TOKEN)}
+        try:
+            self.service = JIRA(JIRA_INSTANCE, **args)
+        except Exception as e:
+            self._logger.error(f"Error connecting to JIRA Instance: {e}")
+            raise
+
+    async def close(self):
+        self.service = None
+
+    async def create(self, hook, *args, **kwargs):
+        """create.
+
+        Create a new Ticket.
+        """
+        project = kwargs.pop("project", JIRA_PROJECT)
+        summary = kwargs.pop("summary", None)
+        description = kwargs.pop("description", None)
+        args = {
+            "project": project,
+            "summary": summary,
+            "description": description,
+            "issuetype": {"name": "Bug"},
+        }
+        if "issuetype" in kwargs:
+            args["issuetype"] = {"name": kwargs["issuetype"]}
+        try:
+            new_issue = self.service.create_issue(**args)
+            print("ISSUE ", new_issue)
+            return new_issue
+        except Exception as e:
+            self._logger.error(f"Error creating Jira Ticket: {e}")
+            raise
+
+
+class JiraIssue(AbstractAction):
+    """An action to process Jira issue events."""
+
+    async def open(self):
+        # Initialize resources if needed
+        pass
+
+    async def close(self):
+        # Clean up resources if needed
+        pass
+
+    async def run(self, hook, event_type, issue_key, issue_fields, **kwargs):
+        self._logger.info(
+            f"Processing Jira issue {event_type}: {issue_key}"
+        )
+        issue = kwargs.get('issue')
+        print('ISSUE > ', issue)
+        # Implement your action logic here
+        # For example, send a notification or update a database
+        # Access issue details via issue_fields
+        return {
+            'status': 'success',
+            'issue_key': issue_key,
+            'event_type': event_type,
+            'issue': issue
+        }

flowtask/hooks/actions/rest.py

@@ -0,0 +1,320 @@
+import asyncio
+from urllib.parse import urlencode
+from functools import partial
+from concurrent.futures import ThreadPoolExecutor
+import aiohttp
+import requests
+from requests.auth import HTTPBasicAuth
+
+# processing the response:
+from bs4 import BeautifulSoup as bs
+from lxml import html, etree
+
+# flowtask related.
+from querysource.libs.encoders import DefaultEncoder
+from ...exceptions import ActionError
+from .abstract import AbstractAction
+
+
+class AbstractREST(AbstractAction):
+    """AbstractREST.
+
+    Base class for actions that interact with REST APIs.
+    """
+
+    timeout: int = 60
+    method: str = "get"
+    headers = {
+        "Accept-Encoding": "gzip, deflate",
+        "DNT": "1",
+        "Connection": "keep-alive",
+        "Upgrade-Insecure-Requests": "1",
+        "cache-control": "max-age=0",
+    }
+    auth_type: str = "key"
+    token_type: str = "Bearer"
+    data_format: str = "raw"
+
+    def __init__(self, hook, *args, **kwargs):
+        self.timeout = int(kwargs.pop("timeout", 60))
+        self.url: str = ""
+        ## Auth Object:
+        self.auth: dict = {}
+        self.accept = kwargs.pop("accept", "application/json")
+        self.content_type = kwargs.pop("content_type", "application/json")
+        self._last_execution: dict = {}
+        ## Headers
+        try:
+            headers = kwargs["headers"]
+        except KeyError:
+            headers = {}
+        self.headers = {
+            "Accept": self.accept,
+            "Content-Type": self.content_type,
+            **self.headers,
+            **headers,
+        }
+        # Language:
+        self.language: list = kwargs.pop("language", ["en-GB", "en-US"])
+        langs = []
+        for lang in self.language:
+            lang_str = f"{lang};q=0.9"
+            langs.append(lang_str)
+        langs.append("ml;q=0.7")
+        self.headers["Accept-Language"] = ",".join(langs)
+        super(AbstractREST, self).__init__(*args, **kwargs)
+        self._encoder = DefaultEncoder()
+
+    def build_url(self, url, queryparams: str = None, args: dict = None):
+        if isinstance(args, dict):
+            u = url.format(**args)
+        else:
+            u = url
+        if queryparams:
+            if "?" in u:
+                full_url = u + "&" + queryparams
+            else:
+                full_url = u + "?" + queryparams
+        else:
+            full_url = u
+        self._logger.debug(f"Action URL: {full_url!s}")
+        return full_url
+
+    async def session(
+        self,
+        url: str = None,
+        method: str = None,
+        data: dict = None,
+        cookies: dict = None,
+        headers: dict = None,
+    ):
+        """
+        session.
+        Connect to an http source using aiohttp.
+        """
+        timeout = aiohttp.ClientTimeout(total=self.timeout)
+        if not url:
+            url = self.url
+        if not method:
+            method = self.method
+        auth = {}
+        if self.auth:
+            auth = self.auth
+        if isinstance(headers, dict):
+            headers = {**self.headers, **headers}
+        else:
+            headers = self.headers
+        async with aiohttp.ClientSession(auth) as session:
+            if method == "get":
+                async with session.get(
+                    url, timeout=timeout, auth=auth, cookies=cookies, headers=headers
+                ) as response:
+                    return response
+            elif method == "post":
+                async with session.post(
+                    url,
+                    headers=headers,
+                    timeout=timeout,
+                    auth=auth,
+                    data=data,
+                    cookies=cookies,
+                ) as response:
+                    return response
+
+    async def request(
+        self,
+        url,
+        method: str = "get",
+        data: dict = None,
+        cookies: dict = None,
+        headers: dict = None,
+    ):
+        """
+        request
+            connect to an http source
+        """
+        result = []
+        error = {}
+        auth = None
+        executor = ThreadPoolExecutor(max_workers=4)
+        if headers is not None and isinstance(headers, dict):
+            self.headers = {**self.headers, **headers}
+        if self.auth_type == "apikey":
+            self.headers["Authorization"] = f"{self.token_type} {self.auth['apikey']}"
+        elif self.auth:
+            if "apikey" in self.auth:
+                self.headers[
+                    "Authorization"
+                ] = f"{self.token_type} {self.auth['apikey']}"
+            elif self.auth_type == "api_key":
+                self.headers = {**self.headers, **self.auth}
+            elif self.auth_type == "key":
+                url = self.build_url(
+                    url, args=self.arguments, queryparams=urlencode(self.auth)
+                )
+            elif self.auth_type == "basic":
+                auth = HTTPBasicAuth(*self.auth)
+            else:
+                auth = HTTPBasicAuth(*self.auth)
+        elif self._user:
+            auth = HTTPBasicAuth(self._user, self._pwd)
+        elif self.auth_type == "basic":
+            auth = HTTPBasicAuth(self._user, self._pwd)
+        ## Start connection:
+        self._logger.notice(f"HTTP: Connecting to {url} using {method}")
+        if method == "get":
+            my_request = partial(
+                requests.get,
+                headers=self.headers,
+                verify=False,
+                auth=auth,
+                params=data,
+                timeout=self.timeout,
+                cookies=cookies,
+            )
+        elif method == "post":
+            if self.data_format == "json":
+                data = self._encoder.dumps(data)
+                my_request = partial(
+                    requests.post,
+                    headers=self.headers,
+                    json={"query": data},
+                    verify=False,
+                    auth=auth,
+                    timeout=self.timeout,
+                    cookies=cookies,
+                )
+            else:
+                data = self._encoder.dumps(data)
+                my_request = partial(
+                    requests.post,
+                    headers=self.headers,
+                    data=data,
+                    verify=False,
+                    auth=auth,
+                    timeout=self.timeout,
+                    cookies=cookies,
+                )
+        elif method == "put":
+            my_request = partial(
+                requests.put,
+                headers=self.headers,
+                data=data,
+                verify=False,
+                auth=auth,
+                timeout=self.timeout,
+            )
+        elif method == "delete":
+            my_request = partial(
+                requests.delete,
+                headers=self.headers,
+                data=data,
+                verify=False,
+                auth=auth,
+                timeout=self.timeout,
+            )
+        elif method == "patch":
+            my_request = partial(
+                requests.patch,
+                headers=self.headers,
+                data=data,
+                verify=False,
+                auth=auth,
+                timeout=self.timeout,
+            )
+        else:
+            my_request = partial(
+                requests.post,
+                headers=self.headers,
+                data=data,
+                verify=False,
+                auth=auth,
+                timeout=self.timeout,
+                cookies=cookies,
+            )
+        # making request
+        loop = asyncio.get_event_loop()
+        future = [loop.run_in_executor(executor, my_request, url)]
+        try:
+            result, error = await self.process_request(future)
+            if error:
+                if isinstance(error, BaseException):
+                    raise error
+                elif isinstance(error, bs):
+                    return (result, error)
+                else:
+                    raise ActionError(str(error))
+            ## saving last execution parameters:
+            self._last_execution = {
+                "url": self.url,
+                "method": method,
+                "data": data,
+                "auth": bool(auth),
+                "headers": self.headers,
+            }
+            return (result, error)
+        except Exception as err:
+            self._logger.exception(err)
+            raise ActionError(f"Error: {err}") from err
+
+    async def process_request(self, future):
+        try:
+            loop = asyncio.get_running_loop()
+            asyncio.set_event_loop(loop)
+            error = None
+            for response in await asyncio.gather(*future):
+                # getting the result, based on the Accept logic
+                if self.accept in (
+                    "application/xhtml+xml",
+                    "text/html",
+                    "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
+                ):
+                    try:
+                        # html parser for lxml
+                        self._parser = html.fromstring(response.text)
+                        # Returning a BeautifulSoup parser
+                        self._bs = bs(response.text, "html.parser")
+                        result = self._bs
+                    except (AttributeError, ValueError) as e:
+                        error = e
+                elif self.accept == "application/xml":
+                    try:
+                        self._parser = etree.fromstring(response.text)
+                    except (AttributeError, ValueError) as e:
+                        error = e
+                elif self.accept in ("text/plain", "text/csv"):
+                    result = response.text
+                elif self.accept == "application/json":
+                    try:
+                        result = self._encoder.loads(
+                            response.text
+                        )  # instead using .json method
+                        # result = response.json()
+                    except (AttributeError, ValueError) as e:
+                        self._logger.error(e)
+                        # is not an json, try first with beautiful soup:
+                        try:
+                            self._bs = bs(response.text, "html.parser")
+                            result = self._bs
+                        except (AttributeError, ValueError) as ex:
+                            error = ex
+                else:
+                    try:
+                        self._bs = bs(response.text, "html.parser")
+                    except (AttributeError, ValueError) as ex:
+                        error = ex
+                    result = response.text
+            return (result, error)
+        except requests.exceptions.ProxyError as err:
+            raise ActionError(f"Proxy Connection Error: {err!r}") from err
+        except requests.ReadTimeout as ex:
+            return ([], ex)
+        except requests.exceptions.Timeout as err:
+            return ([], err)
+        except requests.exceptions.HTTPError as err:
+            return ([], err)
+        except (requests.exceptions.RequestException,) as e:
+            raise ActionError(f"HTTP Connection Error: {e!r}") from e
+        except Exception as e:
+            self.logger.exception(e)
+            raise ActionError(f"HTTP Connection Error: {e!r}") from e