pyswordfish 3.0.4.0__cp312-cp312-win_amd64.whl

swordfish/_function_tools.py

@@ -0,0 +1,124 @@
+from ._swordfishcpp import Constant  # type: ignore
+from ._swordfishcpp import FunctionDef  # type: ignore
+from ._swordfishcpp import ProgrammingError  # type: ignore
+from ._translator import _translate_wrapper
+from ._helper import _ParamAlias
+from typing import Literal, Union, TypeVar, Callable, get_args
+
+import inspect
+
+py_print = print
+py_bool = bool
+py_dict = dict
+
+
+T = TypeVar('T', bound=Callable[..., Constant])
+
+
+def __check_sig(func):
+    params = inspect.signature(func).parameters
+    for name, param in params.items():
+        if param.kind != inspect._ParameterKind.POSITIONAL_OR_KEYWORD:
+            raise ProgrammingError("udf only support POSITIONAL_OR_KEYWORD param.")
+
+
+def __create_udf_from_func(func, is_aggregation, is_state, mode: Literal["default", "translate"], frame=None):
+    __check_sig(func)
+    if mode == "default":
+        if is_state:
+            raise ProgrammingError("udf does not support state function in default mode.")
+        return FunctionDef(func, name=func.__name__, aggregation=is_aggregation)
+    elif mode == "translate":
+        return _translate_wrapper(func, frame=frame, is_aggregation=is_aggregation, is_state=is_state)
+    else:
+        raise ValueError("Invalid mode: " + str(mode))
+
+
+def __set_meta(func, newdef: FunctionDef):
+    signature = inspect.signature(func)
+    params = signature.parameters
+    alias_dict = py_dict()
+    for v in params.values():
+        main_name = v.name
+        annotation = v.annotation
+        alias = []
+        if annotation != inspect._empty and annotation != Constant:
+            types = get_args(annotation)
+            for t in types:
+                if issubclass(t, _ParamAlias):
+                    alias.append(t.name)
+        if alias:
+            for a in alias:
+                alias_dict[a] = main_name
+    if alias_dict:
+        newdef.set_meta(signature, alias_dict)
+    else:
+        newdef.set_meta(signature, None)
+
+
+def swordfish_udf(func=None, *, is_aggregation: py_bool = False, is_state: py_bool = False, mode: Literal["default", "translate"] = "default"):
+    """
+    Registers a user-defined function (UDF) in Swordfish.
+
+    This enables Python functions to be used within Swordfish SQL queries and
+    higher-order functions. The function can be registered in different modes.
+
+    Parameters
+    ----------
+    func : Optional[Callable], optional
+        The UDF to be registered. Defaults to None.
+    is_aggregation : bool, optional
+        Specifies whether the UDF performs aggregation operations. Defaults to
+        False.
+    is_state : bool, optional
+        Specifies whether the UDF maintains state across calls. Defaults to
+        False.
+    mode : Literal["default", "translate"], optional
+        Determines how the UDF is registered. Defaults to "default".
+
+        - "defalut": The function is saved as a Python UDF object which depends
+          on the Python environment to run.
+        - "translate": The function is translated into Swordfish's internal
+          representation. This eliminates Python environment dependency but
+          supports a limited subset of Python syntax.
+
+    Returns
+    -------
+    FunctionDef
+        The FunctionDef object representing the registered UDF.
+
+    Examples
+    --------
+    >>> import swordfish.function as F
+    >>> @F.swordfish_udf(is_aggregation=True)
+    >>> def avg_func(a: int, b: int) -> float:
+    ...     return (a + b) / 2
+
+    >>> @F.swordfish_udf(is_state=True)
+    >>> def counter(state: int, increment: int) -> int:
+    ...     return state + increment
+
+    >>> @F.swordfish_udf(mode="translate")
+    >>> def translate_to_uppercase(text: str) -> str:
+    ...     return text.upper()
+
+    >>> @F.swordfish_udf()
+    >>> def add(a: int, b: int) -> int:
+    ...     return a + b
+    """
+    frame = inspect.currentframe()
+    frame = inspect.getouterframes(frame)[1].frame
+    if func is not None:
+        return __create_udf_from_func(func, is_aggregation, is_state, mode, frame)
+
+    def __inner(_func):
+        return __create_udf_from_func(_func, is_aggregation, is_state, mode, frame)
+    return __inner
+
+
+def builtin_function(functionDef: FunctionDef) -> Callable[[Union[T, FunctionDef]], Union[T, FunctionDef]]:
+    def decorator(func: Union[T, FunctionDef]) -> Union[T, FunctionDef]:
+        functionDef.__doc__ = func.__doc__
+        __set_meta(func, functionDef)
+        return functionDef
+    return decorator

swordfish/_helper.py

@@ -0,0 +1,57 @@
+from typing import TypeVar, Generic, get_args
+
+
+T = TypeVar('T')
+
+
+class _ParamAlias:
+    name: str
+
+
+class Alias(Generic[T]):
+    def __class_getitem__(cls, item):
+        name = get_args(item)[0]
+        return type(name, (_ParamAlias,), {'name': name})
+
+
+class Config(dict):
+    def __init__(self, data: dict = None):
+        super().__init__()
+        for key in dir(self.__class__):
+            if not key.startswith('__') and not key.startswith('_') and not callable(getattr(self.__class__, key)):
+                self[key] = getattr(self.__class__, key)
+        if data is not None:
+            for k, v in data.items():
+                self._update(k, v)
+
+    def __setitem__(self, key, value):
+        self.__dict__[key] = value
+        return super().__setitem__(key, value)
+
+    def __setattr__(self, name, value):
+        self._update(name, value)
+
+    def __getattr__(self, name):
+        return self._get(name)
+
+    def __delattr__(self, name):
+        self._del(name)
+
+    def _update(self, name, value):
+        self.__dict__[name] = value
+        self[name] = value
+
+    def _get(self, name):
+        try:
+            return self.__dict__[name]
+        except KeyError:
+            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")
+
+    def _del(self, name):
+        if name in type(self).__dict__:
+            self._update(name, type(self).__dict__[name])
+        else:
+            if name in self.__dict__:
+                del self.__dict__[name]
+            if name in self:
+                del self[name]

swordfish/_runtime.py

@@ -0,0 +1,158 @@
+from typing import Any, Dict, List, Optional, Literal
+
+from ._swordfishcpp import (  # type: ignore
+    sw_init, sw_uninit, sw_is_ce_edition, sw_info,
+    _global_exec, _global_call, _global_vars, _global_sql,
+    Constant,
+)
+from ._config import config
+from .tools import parse_site
+
+import atexit
+
+
+class Runtime(object):
+    # static
+    _instanc = None
+    _initial = False
+
+    _host: str = None
+    _port: int = None
+    _alias: str = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instanc is None:
+            cls._instanc = super().__new__(cls)
+        return cls._instanc
+
+    def set_info(self, host: str, port: int, alias: str):
+        sw_info(host, port, alias)
+        self._host = host
+        self._port = port
+        self._alias = alias
+
+    def initialize(self, args: Optional[List[str]] = None):
+        if args is None:
+            args = []
+        if not Runtime._initial:
+            sw_init(args)
+            atexit.register(self.clean)
+            Runtime._initial = True
+
+    def clean(self):
+        if Runtime._initial:
+            sw_uninit()
+            Runtime._initial = False
+
+    def check(self):
+        return Runtime._initial
+
+    def __del__(self):
+        self.clean()
+
+
+def _init_without_args():
+    args = ["swordfish"] + config.build()
+    Runtime().initialize(args)
+    Runtime().set_info(*parse_site(config.localSite))
+
+
+def exec(script: str) -> Constant:
+    """
+    Execute the given script.
+
+    Parameters
+    ----------
+    script : str
+        A string containing the script to be executed.
+
+    Returns
+    -------
+    Constant
+        The result of executing the script.
+
+    Examples
+    --------
+    >>> import swordfish as sf
+    >>> sf.exec("1+2")
+    Int(3)
+    """
+    return _global_exec(script, None)
+
+
+def call(function: str, *args) -> Constant:
+    """
+    Call the specified function with the provided arguments.
+
+    Parameters
+    ----------
+    function : str
+        A string indicating the name of the function to be called.
+
+    Returns
+    -------
+    Constant
+        The result of calling the function.
+
+    Examples
+    --------
+    >>> import swordfish as sf
+    >>> sf.call("add", 10, 20)
+    Long(30)
+    """
+    return _global_call(function, *args)
+
+
+def variable(vars: Dict[str, Any]) -> bool:
+    """
+    Set variables with the provided values.
+
+    Parameters
+    ----------
+    vars : dict
+        A dictionary where keys are variable names and values are the
+        corresponding values to be set for those variables.
+
+    Returns
+    -------
+    bool
+        True if the variables were successfully set, False otherwise.
+
+    Examples
+    --------
+    >>> import swordfish as sf
+    >>> vars_to_set = {
+    ...     "username": "john_doe",
+    ...     "age": 30,
+    ...     "is_admin": True,
+    ... }
+    >>> sf.variable(vars_to_set)
+    True
+    """
+    return _global_vars(vars)
+
+
+def sql(sql: str, *, vars: Optional[Dict[str, Any]] = None) -> Constant:
+    """
+    Executes a SQL query.
+
+    Parameters
+    ----------
+    sql : str
+        The SQL query to be executed.
+    vars : dict, optional
+        A dictionary of variables to be involved in the query. Default is None.
+
+    Returns
+    -------
+    Constant
+        The result of executing the SQL query.
+
+    Examples
+    --------
+    >>> import swordfish as sf
+    >>> import swordfish.function as F
+    >>> sf.sql("SELECT * FROM table(1..10 as a) WHERE Func(a) > 0",
+    ...        vars={'Func': F.abs})
+    """
+    return _global_sql(sql, vars)