hyperpocket 0.1.9__py3-none-any.whl → 0.2.0__py3-none-any.whl

hyperpocket/tool/wasm/script.py

@@ -14,29 +14,38 @@ class ScriptRuntime(enum.Enum):
     Python = "python"
     Wasm = "wasm"
 
+
 _RuntimePackageFiles = {
     ScriptRuntime.Node: ["dist/index.js"],
     ScriptRuntime.Python: ["main.py", "requirements.txt"],
     ScriptRuntime.Wasm: ["dist/index.wasm"],
 }
 
+
 class ScriptFileNodeContent(BaseModel):
     contents: str
 
+
 class ScriptFileNode(BaseModel):
-    directory: Optional[dict[str, 'ScriptFileNode']] = None
+    directory: Optional[dict[str, "ScriptFileNode"]] = None
     file: Optional[ScriptFileNodeContent] = None
-    
+
     @classmethod
-    def create_file_tree(cls, path: str, contents: str) -> dict[str, 'ScriptFileNode']:
+    def create_file_tree(cls, path: str, contents: str) -> dict[str, "ScriptFileNode"]:
         path_split = path.split("/")
         if len(path_split) == 1:
-            return {path_split[0]: ScriptFileNode(file=ScriptFileNodeContent(contents=contents))}
-        node = cls.create_file_tree('/'.join(path_split[1:]), contents)
+            return {
+                path_split[0]: ScriptFileNode(
+                    file=ScriptFileNodeContent(contents=contents)
+                )
+            }
+        node = cls.create_file_tree("/".join(path_split[1:]), contents)
         return {path_split[0]: ScriptFileNode(directory=node)}
-    
+
     @staticmethod
-    def merge(a: dict[str, 'ScriptFileNode'], b: [str, 'ScriptFileNode']) -> dict[str, 'ScriptFileNode']:
+    def merge(
+        a: dict[str, "ScriptFileNode"], b: [str, "ScriptFileNode"]
+    ) -> dict[str, "ScriptFileNode"]:
         for k, v in b.items():
             if k in a:
                 if a[k].directory and v.directory:
@@ -53,19 +62,21 @@ class Script(BaseModel):
     tool_path: str
     rendered_html: str
     runtime: ScriptRuntime
-    
+
     def load_file_tree(self) -> dict[str, ScriptFileNode]:
         relpaths = _RuntimePackageFiles[self.runtime]
         file_tree = dict()
         for p in relpaths:
             filepath = pathlib.Path(self.tool_path) / p
             with filepath.open("r") as f:
-                contents = f.read().encode('utf-8')
+                contents = f.read().encode("utf-8")
                 encoded_bytes = base64.b64encode(contents)
                 encoded_str = encoded_bytes.decode()
-                file_tree = ScriptFileNode.merge(file_tree, ScriptFileNode.create_file_tree(p, encoded_str))
+                file_tree = ScriptFileNode.merge(
+                    file_tree, ScriptFileNode.create_file_tree(p, encoded_str)
+                )
         return file_tree
-    
+
     @property
     def package_name(self) -> Optional[str]:
         if self.runtime != ScriptRuntime.Python:
@@ -78,7 +89,7 @@ class Script(BaseModel):
         if not name:
             raise ValueError("Could not find package name")
         return name.replace("-", "_")
-    
+
     @property
     def entrypoint(self) -> str:
         pocket_logger.info(self.tool_path)
@@ -99,10 +110,11 @@ class Script(BaseModel):
         if not wheel_path.exists():
             raise ValueError(f"Wheel file {wheel_path} does not exist")
         return wheel_name
-    
+
     def dist_file_path(self, file_name: str) -> str:
         return str(pathlib.Path(self.tool_path) / "dist" / file_name)
 
+
 class _ScriptStore(object):
     scripts: dict[str, Script] = {}
 
@@ -113,9 +125,10 @@ class _ScriptStore(object):
         if script.id in self.scripts:
             raise ValueError("Script id already exists")
         self.scripts[script.id] = script
-    
+
     def get_script(self, script_id: str) -> Script:
         # ValueError exception is intentional
         return self.scripts[script_id]
 
+
 ScriptStore = _ScriptStore()

hyperpocket/tool/wasm/templates/__init__.py

@@ -1,28 +1,35 @@
 import base64
 import json
 
-from jinja2 import Environment, DictLoader
+from jinja2 import DictLoader, Environment
 
 from hyperpocket.tool.wasm.templates.node import node_template
 from hyperpocket.tool.wasm.templates.python import python_template
 
 TemplateEnvironments = Environment(
-    loader=DictLoader({
-        'python.html': python_template,
-        'node.html': node_template,
-    }),
-    autoescape=False
+    loader=DictLoader(
+        {
+            "python.html": python_template,
+            "node.html": node_template,
+        }
+    ),
+    autoescape=False,
 )
 
 
-def render(language: str, script_id: str, env: dict[str, str], body: str, **kwargs) -> str:
+def render(
+    language: str, script_id: str, env: dict[str, str], body: str, **kwargs
+) -> str:
     env_json = json.dumps(env)
-    template = TemplateEnvironments.get_template(f'{language.lower()}.html')
-    body_bytes = body.encode('utf-8')
+    template = TemplateEnvironments.get_template(f"{language.lower()}.html")
+    body_bytes = body.encode("utf-8")
     body_b64_bytes = base64.b64encode(body_bytes)
-    body_b64 = body_b64_bytes.decode('ascii')
-    return template.render(**{
-                                 'SCRIPT_ID': script_id,
-                                 'ENV_JSON': env_json,
-                                 'BODY_JSON_B64': body_b64,
-                             } | kwargs)
+    body_b64 = body_b64_bytes.decode("ascii")
+    return template.render(
+        **{
+            "SCRIPT_ID": script_id,
+            "ENV_JSON": env_json,
+            "BODY_JSON_B64": body_b64,
+        }
+        | kwargs
+    )

hyperpocket/tool/wasm/templates/node.py

@@ -1,4 +1,4 @@
-node_template = '''
+node_template = """
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -84,4 +84,4 @@ node_template = '''
 </script>
 </body>
 </html>
-'''
+"""

hyperpocket/tool/wasm/templates/python.py

@@ -1,4 +1,4 @@
-python_template = '''
+python_template = """
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -90,4 +90,4 @@ ${packageName}.main()
 </script>
 </body>
 </html>
-'''
+"""

hyperpocket/tool/wasm/tool.py

@@ -1,11 +1,11 @@
-import os
 import json
 import pathlib
 from typing import Any, Optional
 
 import toml
+
 from hyperpocket.auth import AuthProvider
-from hyperpocket.config import settings, pocket_logger
+from hyperpocket.config import pocket_logger
 from hyperpocket.repository import Lock, Lockfile
 from hyperpocket.repository.lock import GitLock, LocalLock
 from hyperpocket.tool import Tool, ToolRequest
@@ -26,15 +26,24 @@ class WasmToolRequest(ToolRequest):
     def __str__(self):
         return f"ToolRequest(lock={self.lock}, rel_path={self.rel_path})"
 
-def from_local(path: str, tool_vars: Optional[dict[str, str]] = None) -> WasmToolRequest:
+
+def from_local(
+    path: str, tool_vars: Optional[dict[str, str]] = None
+) -> WasmToolRequest:
     if tool_vars is None:
         tool_vars = dict()
     return WasmToolRequest(LocalLock(path), "", tool_vars)
 
-def from_git(repository: str, ref: str, rel_path: str, tool_vars: Optional[dict[str, str]] = None) -> WasmToolRequest:
+
+def from_git(
+    repository: str, ref: str, rel_path: str, tool_vars: Optional[dict[str, str]] = None
+) -> WasmToolRequest:
     if not tool_vars:
         tool_vars = dict()
-    return WasmToolRequest(GitLock(repository_url=repository, git_ref=ref), rel_path, tool_vars)
+    return WasmToolRequest(
+        GitLock(repository_url=repository, git_ref=ref), rel_path, tool_vars
+    )
+
 
 class WasmTool(Tool):
     """
@@ -55,7 +64,9 @@ class WasmTool(Tool):
         return self._invoker
 
     @classmethod
-    def from_tool_request(cls, tool_req: WasmToolRequest, lockfile: Lockfile = None, **kwargs) -> 'WasmTool':
+    def from_tool_request(
+        cls, tool_req: WasmToolRequest, lockfile: Lockfile = None, **kwargs
+    ) -> "WasmTool":
         if not lockfile:
             raise ValueError("lockfile is required")
         tool_req.lock = lockfile.get_lock(tool_req.lock.key())
@@ -70,20 +81,22 @@ class WasmTool(Tool):
             with schema_path.open("r") as f:
                 json_schema = json.load(f)
         except Exception as e:
-            pocket_logger.warning(f"{toolpkg_path} failed to load json schema. error : {e}")
+            pocket_logger.warning(
+                f"{toolpkg_path} failed to load json schema. error : {e}"
+            )
             json_schema = None
 
         default_tool_vars = dict()
         try:
             with config_path.open("r") as f:
                 config = toml.load(f)
-                name = config.get('name')
-                description = config.get('description')
-                if language := config.get('language'):
+                name = config.get("name")
+                description = config.get("description")
+                if language := config.get("language"):
                     lang = language.lower()
-                    if lang == 'python':
+                    if lang == "python":
                         runtime = ScriptRuntime.Python
-                    elif lang == 'node':
+                    elif lang == "node":
                         runtime = ScriptRuntime.Node
                     else:
                         raise ValueError(f"The language `{lang}` is not supported.")
@@ -99,7 +112,7 @@ class WasmTool(Tool):
                 readme = f.read()
         else:
             readme = None
-        
+
         return cls(
             name=name,
             description=description,
@@ -127,7 +140,7 @@ class WasmTool(Tool):
             auth_handler=auth_handler,
             scopes=scopes,
         )
-    
+
     def template_arguments(self) -> dict[str, str]:
         return {}
 

hyperpocket/tool_like.py

@@ -1,5 +1,5 @@
-from typing import Union, Callable
+from typing import Callable, Union
 
-from hyperpocket.tool import ToolRequest, Tool
+from hyperpocket.tool import Tool, ToolRequest
 
-ToolLike = Union[Tool, str, Callable, ToolRequest]
+ToolLike = Union[Tool, str, Callable, ToolRequest]

hyperpocket/util/__init__.py

@@ -1 +1 @@
-__all__ = ['json_schema_to_model']
+__all__ = ["json_schema_to_model"]

hyperpocket/util/extract_func_param_desc_from_docstring.py

@@ -23,22 +23,23 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
     if not docstring:
         return {}
 
-    pocket_logger.debug(f"try to extract docstring of {func.__name__} by google style..")
     param_mapping = extract_param_desc_by_google_stype_docstring(docstring, func_params)
     if param_mapping:
-        pocket_logger.debug(f"success extract docstring of {func.__name__} by google style!")
+        pocket_logger.debug(
+            f"success extract docstring of {func.__name__} by google style!"
+        )
         return param_mapping
     pocket_logger.debug(f"not found param desc of {func.__name__} by google style..")
 
-    pocket_logger.debug(f"try to extract docstring of {func.__name__} by other style..")
     param_mapping = extract_param_desc_by_other_styles(docstring, func_params)
     if param_mapping:
-        pocket_logger.debug(f"success extract docstring of {func.__name__} by other style!")
+        pocket_logger.debug(
+            f"success extract docstring of {func.__name__} by other style!"
+        )
         return param_mapping
     pocket_logger.debug(f"not found param desc of {func.__name__} by other styles..")
 
     # Plain Text Style matching
-    pocket_logger.debug(f"try to extract docstring of {func.__name__} by plain text style..")
     param_descriptions = []
     for line in docstring.split("\n"):
         split_line = line.strip().split(":")
@@ -46,18 +47,26 @@ def extract_param_docstring_mapping(func) -> dict[str, str]:
             continue
 
         param_name = split_line[0]
-        cleaned_param_name = clean_bracket_content(param_name)
+        cleaned_param_name = clean_string(param_name)
+        cleaned_param_name = clean_bracket_content(cleaned_param_name)
         description = ":".join(split_line[1:]).strip()
         if cleaned_param_name in func_params:
             param_descriptions.append((cleaned_param_name, description))
 
     # Ensure no duplicates and match with function parameters
-    param_mapping = {param: desc for param, desc in param_descriptions if param in func_params}
+    param_mapping = {
+        param: desc for param, desc in param_descriptions if param in func_params
+    }
     pocket_logger.debug(f"final param_mapping of {func.__name__} : {param_mapping}")
 
     return param_mapping
 
 
+def clean_string(input_string):
+    cleaned = re.sub(r"^[^a-zA-Z_]*|[^a-zA-Z0-9_()\s]*$", "", input_string)
+    return cleaned.strip()
+
+
 def clean_bracket_content(content):
     return re.sub(r"[(\[{<].*?[)\]}>]", "", content)
 
@@ -65,17 +74,21 @@ def clean_bracket_content(content):
 def extract_param_desc_by_other_styles(docstring, func_params) -> dict[str, str]:
     param_descriptions = []
     # Pattern for Sphinx-style or Javadoc-style `:param`, `@param`, `:arg`, `@arg`
-    param_pattern = r"(?:@param|:param|:arg|@arg)\s+(\w+)(?:\s*:\s*|\s+|:\s+)(.*)"
-    matches = re.findall(param_pattern, docstring)
-    for param, desc in matches:
+    param_pattern = r"^\s*(?:@param|:param|:arg|@arg):?\s+(\w+)(?:\((.*?)\))?:?\s*(.*)"
+    matches = re.findall(param_pattern, docstring, re.MULTILINE)
+    for param, _, desc in matches:
         cleaned_param = clean_bracket_content(param)
         param_descriptions.append((cleaned_param, desc.strip()))
     # Ensure no duplicates and match with function parameters
-    param_mapping = {param: desc for param, desc in param_descriptions if param in func_params}
+    param_mapping = {
+        param: desc for param, desc in param_descriptions if param in func_params
+    }
     return param_mapping
 
 
-def extract_param_desc_by_google_stype_docstring(docstring, func_params) -> dict[str, str]:
+def extract_param_desc_by_google_stype_docstring(
+    docstring, func_params
+) -> dict[str, str]:
     # Regex pattern to extract parameter descriptions in Google style
     param_pattern = r"Args:\n(.*?)(?=\n\S|$)"  # Matches the Args: section
     match = re.search(param_pattern, docstring, re.DOTALL)
@@ -87,11 +100,17 @@ def extract_param_desc_by_google_stype_docstring(docstring, func_params) -> dict
     param_descriptions = {}
     for line in param_lines:
         # Match parameter line with "name (type): description"
-        param_match = re.match(r"^\s*(\w+)\s*\(\s*(.*?)\s*\)\s*:\s*(.*)", line)
+        param_match = re.match(
+            r"^[^a-zA-Z_]*([a-zA-Z_]\w*)\s*[\(\[]\s*(.*?)\s*[\)\]]\s*:\s*(.*)", line
+        )
         if param_match:
             param, _, desc = param_match.groups()
             cleaned_param = clean_bracket_content(param)
             param_descriptions[cleaned_param] = desc.strip()
     # Match parameters to descriptions
-    param_mapping = {param: desc for param, desc in param_descriptions.items() if param in func_params}
+    param_mapping = {
+        param: desc
+        for param, desc in param_descriptions.items()
+        if param in func_params
+    }
     return param_mapping

hyperpocket/util/find_all_leaf_class_in_package.py

@@ -1,12 +1,13 @@
-from typing import TypeVar, Type, List
-
+from typing import List, Type, TypeVar
 
 from hyperpocket.util.find_all_subclass_in_package import find_all_subclass_in_package
 
 T = TypeVar("T")
 
 
-def find_all_leaf_class_in_package(package_name: str, interface_type: Type[T]) -> List[T]:
+def find_all_leaf_class_in_package(
+    package_name: str, interface_type: Type[T]
+) -> List[T]:
     parent_class_set = set()
     subclasses = find_all_subclass_in_package(package_name, interface_type)
 

hyperpocket/util/find_all_subclass_in_package.py

@@ -1,7 +1,7 @@
 import importlib
 import inspect
 import pkgutil
-from typing import TypeVar, Type, List
+from typing import List, Type, TypeVar
 
 from hyperpocket.config import pocket_logger
 
@@ -12,7 +12,9 @@ def find_all_subclass_in_package(package_name: str, interface_type: Type[T]) ->
     subclasses = set()
     package = importlib.import_module(package_name)
 
-    for _, module_name, is_pkg in pkgutil.walk_packages(package.__path__, package.__name__ + "."):
+    for _, module_name, is_pkg in pkgutil.walk_packages(
+        package.__path__, package.__name__ + "."
+    ):
         try:
             if "tests" in module_name or is_pkg:
                 continue

hyperpocket/util/flatten_json_schema.py

@@ -6,7 +6,7 @@ def flatten_json_schema(schema: dict):
     Flatten JSON Schema by resolving all $refs using definitions in $defs
     and convert to a fully nested schema.
     """
-    definitions = schema.get('$defs', {})
+    definitions = schema.get("$defs", {})
     schema_copy = copy.deepcopy(schema)
 
     # Resolve references within $defs first
@@ -15,7 +15,7 @@ def flatten_json_schema(schema: dict):
         resolved_definitions[key] = resolve_refs(value, definitions)
 
     # Resolve references in the main schema
-    schema_copy.pop('$defs', None)  # Remove $defs
+    schema_copy.pop("$defs", None)  # Remove $defs
     return resolve_refs(schema_copy, resolved_definitions)
 
 
@@ -28,12 +28,16 @@ def resolve_refs(schema, definitions):
         resolved_schema = {}
         for key, value in schema.items():
             # If $ref exists, resolve the reference
-            if key == '$ref':
-                ref_path = schema['$ref']
-                ref_name = ref_path.split('/')[-1]  # Extract the reference name from $defs/Req -> Req
+            if key == "$ref":
+                ref_path = schema["$ref"]
+                ref_name = ref_path.split("/")[
+                    -1
+                ]  # Extract the reference name from $defs/Req -> Req
                 resolved = definitions.get(ref_name)
                 if resolved:
-                    resolved_schema |= resolve_refs(copy.deepcopy(resolved), definitions)
+                    resolved_schema |= resolve_refs(
+                        copy.deepcopy(resolved), definitions
+                    )
             else:
                 resolved_schema[key] = resolve_refs(value, definitions)
         return resolved_schema

hyperpocket/util/function_to_model.py

@@ -1,25 +1,29 @@
 import inspect
-from inspect import signature, Parameter
-from typing import Any, Dict, Type, Tuple
+from inspect import Parameter, signature
+from typing import Any, Dict, Tuple, Type
 
 from pydantic import BaseModel, create_model
 from pydantic.fields import FieldInfo
 
 from hyperpocket.config import pocket_logger
-from hyperpocket.util.extract_func_param_desc_from_docstring import extract_param_docstring_mapping
+from hyperpocket.util.extract_func_param_desc_from_docstring import (
+    extract_param_docstring_mapping,
+)
 
 
 def function_to_model(func: callable) -> Type[BaseModel]:
     docstring = inspect.getdoc(func)
     if docstring is None:
-        pocket_logger.info("not found docstring. use function name as description instead.")
+        pocket_logger.info(
+            "not found docstring. use function name as description instead."
+        )
         docstring = func.__name__
     fields: Dict[str, Tuple[Type, Any]] = {}
     sig = signature(func)
     param_desc_map = extract_param_docstring_mapping(func)
 
     for param_name, param in sig.parameters.items():
-        if param_name in ('self', 'cls'):
+        if param_name in ("self", "cls"):
             continue
 
         if param.kind == Parameter.VAR_POSITIONAL:
@@ -31,19 +35,36 @@ def function_to_model(func: callable) -> Type[BaseModel]:
             continue
 
         if param.annotation is Parameter.empty:
-            raise Exception(f"Should all arguments be annotated but {param_name} is not annotated")
+            raise Exception(
+                f"Should all arguments be annotated but {param_name} is not annotated"
+            )
 
-        if param.annotation.__module__ == "typing" and param.annotation.__name__ == "Optional":
+        if (
+            param.annotation.__module__ == "typing"
+            and param.annotation.__name__ == "Optional"
+        ):
             fields[param_name] = (
-                param.annotation.__args__[0], FieldInfo(default=param.default, description=param_desc_map.get(param_name, "")))
-        elif param.annotation.__module__ != "builtins" and not issubclass(param.annotation, BaseModel):
+                param.annotation.__args__[0],
+                FieldInfo(
+                    default=param.default,
+                    description=param_desc_map.get(param_name, ""),
+                ),
+            )
+        elif param.annotation.__module__ != "builtins" and not issubclass(
+            param.annotation, BaseModel
+        ):
             raise Exception(
-                f"currently only support builtin types and pydantic BaseModel but {param_name} is not builtin type")
+                f"currently only support builtin types and pydantic BaseModel but {param_name} is not builtin type"
+            )
 
         default = param.default if param.default is not Parameter.empty else ...
 
         fields[param_name] = (
-            param.annotation, FieldInfo(default=default, description=param_desc_map.get(param_name, "")))
+            param.annotation,
+            FieldInfo(default=default, description=param_desc_map.get(param_name, "")),
+        )
 
-    model = create_model(f"{func.__name__.capitalize()}Model", **fields, __doc__=docstring)
+    model = create_model(
+        f"{func.__name__.capitalize()}Model", **fields, __doc__=docstring
+    )
     return model

hyperpocket/util/get_objects_from_subpackage.py

@@ -1,6 +1,6 @@
 import importlib
 import pkgutil
-from typing import Type, Optional
+from typing import Optional, Type
 
 
 def get_objects_from_subpackage(package_name, interface_type: Optional[Type] = None):

hyperpocket/util/json_schema_to_model.py

@@ -1,10 +1,12 @@
 from typing import Type, Union
 
-from pydantic import BaseModel, create_model, Field
+from pydantic import BaseModel, Field, create_model
 
 
 # Convert JSON Schema to a Pydantic model
-def json_schema_to_model(schema: dict, model_name: str = "DynamicModel") -> Type[BaseModel]:
+def json_schema_to_model(
+    schema: dict, model_name: str = "DynamicModel"
+) -> Type[BaseModel]:
     """Recursively create a Pydantic model from a JSON Schema."""
     fields = {}
     config_extra = "forbid"
@@ -16,12 +18,16 @@ def json_schema_to_model(schema: dict, model_name: str = "DynamicModel") -> Type
         if "anyOf" in property_schema:
             types = []
             for item in property_schema["anyOf"]:
-                sub_type = _convert_to_python_type(item["type"], model_name, property_schema)
+                sub_type = _convert_to_python_type(
+                    item["type"], model_name, property_schema
+                )
                 types.append(sub_type)
 
             field_type = Union[tuple(types)]
         elif "type" in property_schema:
-            field_type = _convert_to_python_type(property_schema["type"], model_name, property_schema)
+            field_type = _convert_to_python_type(
+                property_schema["type"], model_name, property_schema
+            )
         else:
             raise RuntimeError("have no type in json schema.")
 
@@ -35,7 +41,10 @@ def json_schema_to_model(schema: dict, model_name: str = "DynamicModel") -> Type
         if required:
             fields[property_name] = (field_type, Field(description=field_description))
         else:
-            fields[property_name] = (field_type, Field(default=field_default, description=field_description))
+            fields[property_name] = (
+                field_type,
+                Field(default=field_default, description=field_description),
+            )
 
     # Handle additionalProperties
     if "additionalProperties" in schema: