flowtask 5.8.4__cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

flowtask/utils/__init__.py

@@ -0,0 +1,24 @@
+"""
+DataIntegration Utils library.
+"""
+from asyncdb.utils.functions import cPrint
+from ..types import SafeDict, AttrDict, NullDefault
+from .functions import check_empty, is_empty, as_boolean, extract_path, extract_string
+from .executor import fnExecutor
+from .mail import MailMessage
+from .uv import install_uvloop
+
+__all__ = [
+    "MailMessage",
+    "fnExecutor",
+    "cPrint",
+    "SafeDict",
+    "AttrDict",
+    "NullDefault",
+    "check_empty",
+    "is_empty",
+    "as_boolean",
+    "extract_path",
+    "extract_string",
+    "install_uvloop",
+]

flowtask/utils/constants.py

@@ -0,0 +1,117 @@
+import builtins
+import logging
+import re
+from collections.abc import Callable
+import querysource.utils.functions as qsfunctions  # pylint: disable=W0401,C0411
+from . import functions as ffunctions  # pylint: disable=W0614,W0401
+from querysource.utils.functions import *
+
+### Constants Utilities for Flowtask
+DI_CONSTANTS = [
+    "CURRENT_DATE",
+    "CURRENT_TIMESTAMP",
+    "CURRENT_YEAR",
+    "CURRENT_MONTH",
+    "CURRENT_MIDNIGHT",
+    "YESTERDAY_TIMESTAMP",
+    "YESTERDAY_MIDNIGHT",
+    "TODAY",
+    "YESTERDAY",
+    "FDOM",
+    "LDOM",
+]
+
+excel_based = (
+    "application/vnd.ms-excel.sheet.binary.macroEnabled.12",  # XLSB
+    "application/vnd.ms-excel.sheet.macroEnabled.12",  # XLSM
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",  # XLSX
+    "application/vnd.ms-excel",  # XLS
+    "text/xml",  # XML
+)
+
+
+it_func = re.compile(r"^(\w+)\((.*)\)")
+
+
+def is_constant(value):
+    return value in DI_CONSTANTS
+
+
+def is_function(value):
+    if "(" in str(value):
+        fn, _ = it_func.match(value).groups()
+        # also, I need to know if exists on global values
+        func = globals()[fn]
+        if not func:
+            try:
+                func = getattr(ffunctions, value)
+            except AttributeError:
+                try:
+                    func = getattr(qsfunctions, value)
+                except AttributeError:
+                    func = None
+        if not func:
+            return False
+        else:
+            return True
+    else:
+        return False
+
+
+def get_func_value(value):
+    result = None
+    f, args = it_func.match(value).groups()
+    args = args.split(",")
+    logging.debug(
+        f'Conditions: Calling function {value}, {f}'
+    )
+    try:
+        try:
+            func = getattr(ffunctions, f)
+        except AttributeError:
+            try:
+                func = getattr(qsfunctions, f)
+            except AttributeError:
+                func = globals()[f]
+        if not func:
+            try:
+                func = getattr(builtins, f)
+            except AttributeError:
+                return None
+        if callable(func):
+            result = func(*args)
+    except Exception as err:
+        logging.exception(err)
+    finally:
+        return result
+
+
+def get_constant(value: str, *args, **kwargs) -> Callable:
+    fn = None
+    try:
+        f = value.lower()
+        print(
+            f':::: Conditions: Calling function {value}, {f}'
+        )
+        if value in DI_CONSTANTS:
+            fn = globals()[f](*args, **kwargs)
+        else:
+            try:
+                func = getattr(ffunctions, f)
+            except AttributeError:
+                try:
+                    func = getattr(qsfunctions, f)
+                except AttributeError:
+                    func = globals()[f]
+            if not func:
+                try:
+                    func = getattr(builtins, f)
+                except AttributeError:
+                    return None
+            if func and callable(func):
+                try:
+                    fn = func(*args, **kwargs)
+                except Exception as err:
+                    raise Exception(err) from err
+    finally:
+        return fn

flowtask/utils/encoders.py

@@ -0,0 +1,21 @@
+import sys
+
+from .json import JSONContent, json_encoder, json_decoder
+
+DefaultEncoder = JSONContent
+
+if sys.version_info < (3, 10):
+    from typing_extensions import ParamSpec
+else:
+    from typing import ParamSpec
+P = ParamSpec("P")
+
+
+class BaseEncoder:
+    """
+    Encoder replacement for json.dumps using orjson
+    """
+
+    def __init__(self, *args: P.args, **kwargs: P.kwargs):
+        encoder = DefaultEncoder(*args, **kwargs)
+        self.encode = encoder.__call__

flowtask/utils/executor.py

@@ -0,0 +1,112 @@
+"""
+Function Executor.
+"""
+import logging
+import traceback
+import importlib
+from typing import Any
+import builtins
+from collections.abc import Callable
+from querysource.types.validators import Entity
+import querysource.utils.functions as qsfunctions
+from . import functions as ffunctions
+
+
+def getFunction(fname: str) -> callable:
+    """
+    Get any function using name.
+    """
+    try:
+        return getattr(qsfunctions, fname)
+    except (TypeError, AttributeError):
+        pass
+    try:
+        return getattr(ffunctions, fname)
+    except (TypeError, AttributeError):
+        pass
+    try:
+        func = globals().get(fname)
+        if func:
+            return func
+    except AttributeError:
+        pass
+    try:
+        return getattr(builtins, fname)
+    except AttributeError:
+        pass
+    # If the function name contains dots, try to import the module and get the attribute
+    if '.' in fname:
+        components = fname.split('.')
+        module_name = '.'.join(components[:-1])
+        attr_name = components[-1]
+
+        try:
+            module = importlib.import_module(module_name)
+            func = getattr(module, attr_name)
+            return func
+        except (ImportError, AttributeError) as e:
+            # Function doesn't exists:
+            print(f'Cannot find Module {e}')
+    logging.warning(
+        f"Function {fname} not found in any known modules."
+    )
+    return None
+
+
+def fnExecutor(
+    value: Any, env: Callable = None, escape: bool = False, quoting: bool = False
+) -> Any:
+    if isinstance(value, list):
+        try:
+            fname, args = (value + [{}])[:2]  # Safely unpack with default args
+            func = getFunction(fname)
+            if not func:
+                logging.warning(
+                    f"Function {fname} doesn't exist in Builtins or Flowtask."
+                )
+                return None
+            if isinstance(args, list):
+                try:
+                    return func(*args)
+                except Exception as e:
+                    print("FN > ", e)
+                    traceback.print_exc()
+                    return ""
+            if isinstance(args, dict):
+                if env is not None:
+                    args["env"] = env
+                try:
+                    try:
+                        return func(**args)
+                    except TypeError:
+                        if "env" in args:
+                            del args["env"]
+                        return func(**args)
+                    except Exception as e:
+                        print("FN > ", e)
+                except (TypeError, ValueError) as err:
+                    logging.exception(
+                        str(err),
+                        exc_info=True,
+                        stack_info=True
+                    )
+                    traceback.print_exc()
+                    return ""
+            else:
+                try:
+                    return func()
+                except (TypeError, ValueError):
+                    return ""
+        except (NameError, KeyError) as err:
+            logging.exception(str(err), exc_info=True, stack_info=True)
+            traceback.print_exc()
+            return ""
+    else:
+        if isinstance(value, str):
+            if escape is True:
+                return f"'{str(value)}'"
+            elif quoting is True:
+                return Entity.quoteString(value)
+            else:
+                return f"{str(value)}"
+        return value