hyperpocket 0.4.5__py3-none-any.whl → 0.5.1__py3-none-any.whl

hyperpocket/server/server.py

@@ -1,101 +1,91 @@
 import asyncio
-import enum
-import uuid
+import threading
 from typing import Optional
 
-import multiprocess as mp
 from fastapi import FastAPI
 from uvicorn import Config, Server
 
 from hyperpocket.config import config, pocket_logger
-from hyperpocket.pocket_core import PocketCore
 from hyperpocket.server.auth import auth_router
 
 
-class PocketServerOperations(enum.Enum):
-    CALL = "call"
-    PREPARE_AUTH = "prepare_auth"
-    AUTHENTICATE = "authenticate"
-    TOOL_CALL = "tool_call"
-    PLUG_CORE = "plug_core"
-
-
 class PocketServer(object):
+    _instance: "PocketServer" = None
+
     fastapi_app: Optional[FastAPI]
     main_server: Optional[Server]
     internal_server_port: int
     proxy_server: Optional[Server]
     proxy_port: int
-    pipe: mp.Pipe
-    process: mp.Process
-    future_store: dict[str, asyncio.Future]
-    torn_down: bool = False
-    _uidset: set
-    _cores: dict[str, PocketCore]
+
+    thread: threading.Thread
+    _initialized: bool
+    _initialization_event: threading.Event
+    _initialization_error: Optional[Exception]
 
     def __init__(self):
         self._initialized = False
+        self._initialization_event = threading.Event()
+        self._initialization_error = None
+
         self.internal_server_port = config().internal_server_port
         self.proxy_port = config().public_server_port
-        self._uidset = set()
-        self.future_store = dict()
         self.fastapi_app = None
         self.main_server = None
-        self._cores = dict()
 
-    # should be called in child process
-    def _plug_core(self, pocket_uid: str, pocket_core: PocketCore, *_a, **_kw):
-        # extend http routers from each docks
-        dock_routes = set([str(r) for r in self.fastapi_app.routes])
-
-        for dock in pocket_core.docks:
-            # check duplicated api route
-            dock_route = set([str(r) for r in dock.router.routes])
-            if dock_route in dock_routes:
-                continue
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            cls._instance = cls()
+            cls._instance.run()
+        return cls._instance
 
-            dock_routes.update(dock_route)
-            self.fastapi_app.include_router(dock.router)
+    def teardown(self):
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        loop.run_until_complete(self._teardown())
+        loop.close()
+
+    async def _teardown(self):
+        if self.thread.is_alive():
+            if self.main_server:
+                self.main_server.should_exit = True
+            if self.proxy_server:
+                self.proxy_server.should_exit = True
+
+            while self.thread.is_alive():
+                await asyncio.sleep(0)
 
-        # keep pocket core
-        self._cores[pocket_uid] = pocket_core
+        self.thread.join()
 
-    # should be called in parent process
-    async def plug_core(self, pocket_uid: str, pocket_core: PocketCore):
-        await self.call_in_subprocess(
-            PocketServerOperations.PLUG_CORE,
-            pocket_uid,
-            tuple(),
-            {
-                "pocket_uid": pocket_uid,
-                "pocket_core": pocket_core,
-            },
+    def run(self):
+        self.thread = threading.Thread(
+            target=self._run,
+            daemon=True
         )
+        self.thread.start()
+        self._wait_initialized()
 
-    @classmethod
-    def get_instance_and_refcnt_up(cls, uid: str):
-        if cls.__dict__.get("_instance") is None:
-            cls._instance = cls()
-            cls._instance.run()
-        cls._instance.refcnt_up(uid)
-        return cls._instance
+    def _run(self):
+        try:
+            # init process
+            self.fastapi_app = self._create_fastapi_app()
+            self.main_server = self._create_main_server(self.fastapi_app)
+            self.proxy_server = self._create_https_proxy_server()
+            self._report_initialized()
 
-    def refcnt_up(self, uid: str):
-        self._uidset.add(uid)
+            loop = asyncio.new_event_loop()
+            error = loop.run_until_complete(self._run_async())
+            loop.close()
 
-    def refcnt_down(self, uid: str):
-        if uid in self._uidset:
-            self._uidset.remove(uid)
-            if len(self._uidset) == 0:
-                self._instance.teardown()
+            if error:
+                raise error
 
-    def teardown(self):
-        # @XXX(seokju) is it ok to call this method both in __del__ and __exit__?
-        if self.torn_down:
-            return
-        self.torn_down = True
-        self.process.terminate()
-        self.process.join()
+        except Exception as error:
+            self._report_initialized(error)
 
     async def _run_async(self):
         try:
@@ -104,175 +94,34 @@ class PocketServer(object):
                 self.proxy_server.serve()
                 if self.proxy_server is not None
                 else asyncio.sleep(0),
-                self.poll_in_child(),
+                return_exceptions=True
             )
+            return None
         except Exception as e:
             pocket_logger.warning(f"failed to start pocket server. error : {e}")
-
-    async def poll_in_child(self):
-        loop = asyncio.get_running_loop()
-        _, conn = self.pipe
-
-        async def _acall(_conn, _future_uid, _core_uid, _args, _kwargs):
-            try:
-                core = self._cores[_core_uid]
-                result = await core.acall(*_args, **_kwargs)
-                error = None
-            except Exception as e:
-                pocket_logger.error(f"failed in pocket subprocess. error: {e}")
-                result = None
-                error = e
-            _conn.send((_future_uid, result, error))
-
-        async def _prepare(_conn, _future_uid, _core_uid, a, kw):
-            try:
-                core = self._cores[_core_uid]
-                result = core.prepare_auth(*a, **kw)
-                error = None
-            except Exception as e:
-                pocket_logger.error(
-                    f"failed to prepare in pocket subprocess. error: {e}"
-                )
-                result = None
-                error = e
-
-            _conn.send((_future_uid, result, error))
-
-        async def _authenticate(_conn, _future_uid, _core_uid, a, kw):
-            try:
-                core = self._cores[_core_uid]
-                result = await core.authenticate(*a, **kw)
-                error = None
-            except Exception as e:
-                pocket_logger.error(
-                    f"failed to authenticate in pocket subprocess. error: {e}"
-                )
-                result = None
-                error = e
-
-            _conn.send((_future_uid, result, error))
-
-        async def _tool_call(_conn, _future_uid, _core_uid, a, kw):
-            try:
-                core = self._cores[_core_uid]
-                result = await core.tool_call(*a, **kw)
-                error = None
-            except Exception as e:
-                pocket_logger.error(
-                    f"failed to tool_call in pocket subprocess. error: {e}"
-                )
-                result = None
-                error = e
-
-            _conn.send((_future_uid, result, error))
-
-        async def _plug_core(_conn, _future_uid, _core_uid, a, kw):
-            try:
-                self._plug_core(*a, **kw)
-                _conn.send((_future_uid, None, None))
-            except Exception as e:
-                pocket_logger.error(
-                    f"failed to plug_core in pocket subprocess. error: {e}"
-                )
-                _conn.send((_future_uid, None, e))
-
-        while True:
-            if conn.poll():
-                op, future_uid, core_uid, args, kwargs = conn.recv()
-                if op == PocketServerOperations.CALL:
-                    loop.create_task(_acall(conn, future_uid, core_uid, args, kwargs))
-                elif op == PocketServerOperations.PREPARE_AUTH:
-                    loop.create_task(_prepare(conn, future_uid, core_uid, args, kwargs))
-                elif op == PocketServerOperations.AUTHENTICATE:
-                    loop.create_task(_authenticate(conn, future_uid, core_uid, args, kwargs))
-                elif op == PocketServerOperations.TOOL_CALL:
-                    loop.create_task(_tool_call(conn, future_uid, core_uid, args, kwargs))
-                elif op == PocketServerOperations.PLUG_CORE:
-                    loop.create_task(_plug_core(conn, future_uid, core_uid, args, kwargs))
-                else:
-                    raise ValueError(f"Unknown operation: {op}")
-            else:
-                await asyncio.sleep(0)
-
-    def send_in_parent(self, op: PocketServerOperations, pocket_uid: str, args: tuple, kwargs: dict):
-        conn, _ = self.pipe
-        future_uid = str(uuid.uuid4())
-        message = (op, future_uid, pocket_uid, args, kwargs)
-        future = asyncio.Future()
-        self.future_store[future_uid] = future
-        conn.send(message)
-        return future_uid
-
-    async def poll_in_parent(self):
-        conn, _ = self.pipe
-        while True:
-            if conn.poll():
-                uid, result, error = conn.recv()
-                future = self.future_store[uid]
-                if error:
-                    future.set_exception(error)
-                else:
-                    future.set_result(result)
-                break
-            else:
-                await asyncio.sleep(0)
-
-    async def call_in_subprocess(
-        self, op: PocketServerOperations, pocket_uid: str, args: tuple, kwargs: dict
-    ):
-        uid = self.send_in_parent(op, pocket_uid, args, kwargs)
-        loop = asyncio.get_running_loop()
-        loop.create_task(self.poll_in_parent())
-        return await self.future_store[uid]
-
-    def run(self):
-        self._set_mp_start_method()
-
-        error_queue = mp.Queue()
-        self.pipe = mp.Pipe()
-        self.process = mp.Process(
-            target=self._run
-        )
-        self.process.start()  # process start
-
-        if not error_queue.empty():
-            error_message = error_queue.get()
-            raise error_message
+            return e
 
     def _report_initialized(self, error: Optional[Exception] = None):
-        _, conn = self.pipe
-        conn.send(('server-initialization', error,))
+        if error:
+            pocket_logger.warning(f"Server initialization failed: {error}")
+            self._initialization_error = error
+        self._initialization_event.set()
 
-    def wait_initialized(self):
+    def _wait_initialized(self):
         if self._initialized:
             return
-        conn, _ = self.pipe
-        while True:
-            if conn.poll():
-                _, error = conn.recv()
-                if error:
-                    raise error
-                break
-        self._initialized = True
 
-    def _run(self):
-        try:
-            # init process
-            self.fastapi_app = self._create_fastapi_app()
-            self.main_server = self._create_main_server(self.fastapi_app)
-            self.proxy_server = self._create_https_proxy_server()
-            self._report_initialized()
+        self._initialization_event.wait()
+        if self._initialization_error:
+            raise self._initialization_error
 
-            loop = asyncio.new_event_loop()
-            loop.run_until_complete(self._run_async())
-            loop.close()
-        except Exception as error:
-            self._report_initialized(error)
+        self._initialization_event.clear()
+        self._initialized = True
 
     def _create_fastapi_app(self) -> FastAPI:
         app = FastAPI()
-        app.include_router(auth_router)
         app.add_api_route("/health", lambda: {"status": "ok"}, methods=["GET"])
+        app.include_router(auth_router)
         return app
 
     def _create_main_server(self, app: FastAPI) -> Server:
@@ -307,21 +156,3 @@ class PocketServer(object):
         )
         proxy_server = Server(_config)
         return proxy_server
-
-    def _set_mp_start_method(self):
-        import platform
-
-        os_name = platform.system()
-        if os_name == "Windows":
-            mp.set_start_method("spawn", force=True)
-            pocket_logger.debug("Process start method set to 'spawn' for Windows.")
-        elif os_name == "Darwin":  # macOS
-            mp.set_start_method("spawn", force=True)
-            pocket_logger.debug("Process start method set to 'spawn' for macOS.")
-        elif os_name == "Linux":
-            mp.set_start_method("fork", force=True)
-            pocket_logger.debug("Process start method set to 'fork' for Linux.")
-        else:
-            pocket_logger.debug(
-                f"Unrecognized OS: {os_name}. Default start method will be used."
-            )

hyperpocket/session/in_memory.py

@@ -19,49 +19,42 @@ InMemorySessionValue = BaseSessionValue
 class InMemorySessionStorage(
     SessionStorageInterface[InMemorySessionKey, InMemorySessionValue]
 ):
-    _instance = None
-    _is_initialized = False
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super(InMemorySessionStorage, cls).__new__(cls)
-            cls._instance._is_initialized = False
-        return cls._instance
+    storage = {}
 
     def __init__(self, session_config: SessionConfigInMemory):
-        if not self._is_initialized:
-            super().__init__()
-            self.storage: Dict[InMemorySessionKey, InMemorySessionValue] = {}
-            self._is_initialized = True
+        super().__init__()
 
     @classmethod
     def session_storage_type(cls) -> SessionType:
         return SessionType.IN_MEMORY
 
+    @classmethod
     def get(
-        self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
+        cls, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
     ) -> Optional[V]:
-        key = self._make_session_key(auth_provider.name, thread_id, profile)
-        return self.storage.get(key, None)
+        key = cls._make_session_key(auth_provider.name, thread_id, profile)
+        return cls.storage.get(key, None)
 
+    @classmethod
     def get_by_thread_id(
-        self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs
+        cls, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs
     ) -> List[V]:
         if auth_provider is None:
             auth_provider_name = ".*"
         else:
             auth_provider_name = auth_provider.name
 
-        pattern = rf"{self._make_session_key(auth_provider_name, thread_id, '.*')}"
+        pattern = rf"{cls._make_session_key(auth_provider_name, thread_id, '.*')}"
         compiled = re.compile(pattern)
 
         session_list = [
-            value for key, value in self.storage.items() if compiled.match(key)
+            value for key, value in cls.storage.items() if compiled.match(key)
         ]
         return session_list
 
+    @classmethod
     def set(
-        self,
+        cls,
         auth_provider: AuthProvider,
         thread_id: str,
         profile: str,
@@ -71,8 +64,8 @@ class InMemorySessionStorage(
         is_auth_scope_universal: bool,
         **kwargs,
     ) -> V:
-        key = self._make_session_key(auth_provider.name, thread_id, profile)
-        session = self._make_session(
+        key = cls._make_session_key(auth_provider.name, thread_id, profile)
+        session = cls._make_session(
             auth_provider_name=auth_provider.name,
             auth_scopes=auth_scopes,
             auth_resolve_uid=auth_resolve_uid,
@@ -80,15 +73,16 @@ class InMemorySessionStorage(
             is_auth_scope_universal=is_auth_scope_universal,
         )
 
-        self.storage[key] = session
+        cls.storage[key] = session
         return session
 
+    @classmethod
     def delete(
-        self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
+        cls, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
     ) -> bool:
-        key = self._make_session_key(auth_provider.name, thread_id, profile)
-        if key in self.storage:
-            self.storage.pop(key)
+        key = cls._make_session_key(auth_provider.name, thread_id, profile)
+        if key in cls.storage:
+            cls.storage.pop(key)
             return True
 
         return False

hyperpocket/tool/__init__.py

@@ -1,10 +1,9 @@
 from hyperpocket.tool.function import from_dock, from_func, function_tool
-from hyperpocket.tool.tool import Tool, ToolAuth, ToolRequest
+from hyperpocket.tool.tool import Tool, ToolAuth
 
 __all__ = [
     "Tool",
     "ToolAuth",
-    "ToolRequest",
     "from_dock",
     "from_func",
     "function_tool",

hyperpocket/tool/dock/dock.py

@@ -1,34 +1,15 @@
 import abc
-from typing import Any
+from typing import TypeVar, Generic
 
-from fastapi import APIRouter
-
-from hyperpocket.tool import ToolRequest
 from hyperpocket.tool.function import FunctionTool
 
+DockToolLike = TypeVar("DockToolLike")
 
-class Dock(abc.ABC):
-    _tool_requests: list[ToolRequest]
-    _dock_http_router: APIRouter
-    _dock_vars: dict[str, str]
-
-    def __init__(self, dock_vars: dict[str, str] = None):
-        self._dock_http_router = APIRouter()
-        self._tool_requests = []
-        self._dock_vars = dock_vars if dock_vars is not None else {}
-
-    @property
-    def router(self):
-        return self._dock_http_router
-
-    @abc.abstractmethod
-    def plug(self, req_like: Any, **kwargs):
-        raise NotImplementedError
 
+class Dock(Generic[DockToolLike], abc.ABC):
     @abc.abstractmethod
-    def tools(self) -> list[FunctionTool]:
+    def dock(self, tool_like: DockToolLike, *args, **kwargs) -> FunctionTool:
         raise NotImplementedError
 
-    @abc.abstractmethod
-    async def teardown(self):
-        raise NotImplementedError
+    def __call__(self, *args, **kwargs):
+        return self.dock(*args, **kwargs)

hyperpocket/tool/function/tool.py

@@ -121,6 +121,9 @@ class FunctionTool(Tool):
         if tool_vars is None:
             tool_vars = dict()
 
+        if afunc is None and inspect.iscoroutinefunction(func):
+            afunc = func
+
         if isinstance(func, FunctionTool):
             if tool_vars is not None:
                 func.override_tool_variables(tool_vars)
@@ -133,7 +136,7 @@ class FunctionTool(Tool):
             raise ValueError("FunctionTool can only be created from a callable")
 
         name = name or (func and func.__name__) or (afunc and afunc.__name__)
-        description = description or (func and func.__doc__) or (afunc and func.__doc__)
+        description = description or (func and func.__doc__) or (afunc and func.__doc__) or name
         schema = json_schema or \
                  (func and function_to_model(func).model_json_schema()) or \
                  (afunc and function_to_model(afunc).model_json_schema())

hyperpocket/tool/tool.py

@@ -17,52 +17,20 @@ class ToolAuth(BaseModel):
     scopes: list[str] = Field(
         default=None,
         description="Indicates which authentication provider’s credentials are required to invoke the tool. "
-        "If auth_provider is not specified, the tool is considered to require no authentication.",
+                    "If auth_provider is not specified, the tool is considered to require no authentication.",
     )
     auth_provider: Optional[AuthProvider] = Field(
         default=None,
         description="Specifies which authentication handler should be used when invoking the tool. "
-        "If auth_handler is not specified, the default handler of the authentication provider will be used.",
+                    "If auth_handler is not specified, the default handler of the authentication provider will be used.",
     )
     auth_handler: Optional[str] = Field(
         default=None,
         description="Indicates the authentication scopes required to invoke the tool. "
-        "If authentication is not performed or the authentication handler is non-scoped, the value should be None.",
+                    "If authentication is not performed or the authentication handler is non-scoped, the value should be None.",
     )
 
 
-class ToolRequest(abc.ABC):
-    postprocessings: Optional[list[Callable]] = None
-    overridden_tool_vars: dict[str, str] = Field(
-        default_factory=dict, description="overridden tool variables"
-    )
-
-    @abc.abstractmethod
-    def __str__(self):
-        raise NotImplementedError
-
-    def add_postprocessing(self, postprocessing: Callable):
-        if self.postprocessings is None:
-            self.postprocessings = [postprocessing]
-        else:
-            self.postprocessings.append(postprocessing)
-
-    def __or__(self, other: Callable):
-        self.add_postprocessing(other)
-        return self
-
-    def with_postprocessings(self, postprocessings: list[Callable]):
-        if self.postprocessings is None:
-            self.postprocessings = postprocessings
-        else:
-            self.postprocessings.extend(postprocessings)
-        return self
-
-    def override_tool_variables(self, override_vars: dict[str, str]) -> "ToolRequest":
-        self.overridden_tool_vars = override_vars
-        return self
-
-
 class Tool(BaseModel, abc.ABC):
     """
     Pocket Tool Interface
@@ -191,3 +159,6 @@ class Tool(BaseModel, abc.ABC):
         else:
             self.postprocessings.extend(postprocessings)
         return self
+
+    def __str__(self) -> str:
+        return self.name

hyperpocket/tool_like.py

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

hyperpocket/util/git_parser.py

@@ -0,0 +1,63 @@
+import git
+
+
+class GitParser:
+    git_branches_cache: dict[str, dict[str, str]] = {}
+
+    @classmethod
+    def get_git_branches(cls, repo_url) -> dict[str, str]:
+        if cls.git_branches_cache.get(repo_url) is None:
+            ls_lists = git.cmd.Git().ls_remote(repo_url)
+
+            branches = {}
+            for line in ls_lists.split("\n"):
+                sha, ref = line.split("\t")
+                if ref == "HEAD":
+                    branches["HEAD"] = sha
+                elif ref.startswith("refs/heads/"):
+                    branch_name = ref.replace("refs/heads/", "")
+                    branches[branch_name] = sha
+            cls.git_branches_cache[repo_url] = branches
+        return cls.git_branches_cache[repo_url]
+
+    @classmethod
+    def parse_repo_url(cls, repo_url: str) -> tuple[str, str, str, str]:
+        """
+        Parses a GitHub repository URL with optional branch and path information.
+
+        Returns:
+            Tuple[str, str, str, str]: base_repo, branch_name, directory_path, git_sha
+        """
+        if not repo_url.startswith("https://github.com/"):
+            raise AttributeError("Only GitHub URLs are supported")
+
+        # Remove the base URL and split the path
+        repo_path = repo_url.removeprefix("https://github.com/")
+        repo_path_list = repo_path.split("/")
+
+        # Check if the URL contains 'tree' (indicating branch and sub-path information)
+        if "tree" not in repo_path_list:
+            # If no 'tree', return the full repository URL
+            git_sha = cls.get_git_branches(repo_url)["HEAD"]
+            return repo_url, "HEAD", "", git_sha
+
+        # Parse base repo URL and remaining path
+        tree_index = repo_path_list.index("tree")
+        base_repo = f"https://github.com/{'/'.join(repo_path_list[:tree_index])}"
+        sub_path = repo_path_list[tree_index + 1:]
+
+        # Fetch branch information
+        branches = cls.get_git_branches(base_repo)
+
+        # Find branch and sub-directory path
+        for idx in range(1, len(sub_path) + 1):
+            branch_name = "/".join(sub_path[:idx])
+            if branch_name in branches:
+                git_sha = branches[branch_name]
+                directory_path = (
+                    "/".join(sub_path[idx:]) if idx < len(sub_path) else None
+                )
+                return base_repo, branch_name, directory_path, git_sha
+
+        # If no valid branch is found, raise an error
+        raise ValueError("Branch not found in repository")

hyperpocket/util/short_hashing_str.py

@@ -0,0 +1,5 @@
+import hashlib
+
+
+def short_hashing_str(text, length=10):
+    return hashlib.sha256(text.encode()).hexdigest()[:length]