hyperpocket 0.0.1__py3-none-any.whl

hyperpocket/server/tool/__init__.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from hyperpocket.server.tool.wasm import wasm_tool_router
+
+tool_router = APIRouter(
+    prefix="/tools",
+)
+tool_router.include_router(wasm_tool_router)
+
+__all__ = ["tool_router"]

hyperpocket/server/tool/dto/script.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel, Field
+
+from hyperpocket.tool.wasm.script import ScriptFileNode
+
+
+class Script(BaseModel):
+    id: str = Field(alias='id')
+    tool_id: str = Field(alias='tool_id')
+
+
+class ScriptStdout(BaseModel):
+    stdout: str = Field(alias='stdout')
+
+class ScriptFileTree(BaseModel):
+    tree: dict[str, ScriptFileNode] = Field(alias='tree')

hyperpocket/server/tool/wasm.py

@@ -0,0 +1,31 @@
+from fastapi import APIRouter
+from fastapi.responses import HTMLResponse
+
+from hyperpocket.futures import FutureStore
+from hyperpocket.server.tool.dto import script as scriptdto
+from hyperpocket.tool.wasm.script import ScriptStore
+
+wasm_tool_router = APIRouter(
+    prefix="/wasm"
+)
+
+
+@wasm_tool_router.get("/scripts/{script_id}/browse", response_class=HTMLResponse)
+async def browse_script_page(script_id: str):
+    html = ScriptStore.get_script(script_id).rendered_html
+    return HTMLResponse(content=html)
+
+
+@wasm_tool_router.post("/scripts/{script_id}/done")
+async def done_script_page(script_id: str, req: scriptdto.ScriptStdout) -> scriptdto.ScriptStdout:
+    FutureStore.resolve_future(script_id, req.stdout)
+    return scriptdto.ScriptStdout(stdout=req.stdout)
+
+@wasm_tool_router.post("/scripts/{script_id}/fail")
+async def fail_script_page(script_id: str, req: scriptdto.ScriptStdout) -> scriptdto.ScriptStdout:
+    pass
+
+@wasm_tool_router.get("/scripts/{script_id}/file_tree")
+async def get_file_tree(script_id: str) -> scriptdto.ScriptFileTree:
+    script = ScriptStore.get_script(script_id)
+    return scriptdto.ScriptFileTree(tree=script.load_file_tree())

hyperpocket/session/README.KR.md

@@ -0,0 +1,62 @@
+# Session Storage
+
+유저의 authentication(auth) session을 저장하기 위한 storage
+
+## Current supported session storage
+
+- [x] InMemory
+- [x] Redis
+- [ ] Postgres
+- [ ] Mysql
+- [ ] Mongodb
+
+## SessionKey
+
+세션 키는 유저의 인증 정보를 식별하기 위한 유니크 키이다.
+
+일반적으로 세션 키는 다음 세 가지 요소로 식별될 수 있다.
+
+- auth provider
+- profile
+- thread_id
+
+하나의 auth provider에서는 하나의 session만 가질 수 있다.
+
+- 예를 들어 slack token으로 이미 인증한 사용자가 oauth로 인증하려 하면 이전 세션은 사라지게 된다.
+
+- profile은 pocket에서 지원하는 개념으로 하나의 thread_id에 여러 profile이 존재할 수 있다.
+
+- profile을 이용해 한 사용자는 여러 persona를 갖고 작업을 수행하도록 할 수 있다.
+    - e.g., A group의 슬랙 메세지를 읽어 B group으로 요약해서 전달
+
+## BaseSessionValue
+
+```python
+class BaseSessionValue(BaseModel):
+    auth_provider_name: str
+    auth_context: Optional[AuthContext] = None
+    scoped: bool
+    auth_scopes: Optional[Set[str]] = None
+    auth_resolve_uid: Optional[str] = None
+```
+
+기본적으로 Session에는 다음 정보들을 갖고 있다.
+
+- auth_provider_name : 현재 세션을 인증한 auth provider name
+- auth_context : 실제 세션 내용이 들어있는 auth context
+- scoped : 현재 세션이 scoped session인지 여부
+- auth_scopes : 현재 세션의 auth scopes. scoped session의 경우에만 존재
+- auth_resolve_uid : 유저가 auth 인증을 완료했는지를 비동기적으로 확인하기 위한 uid
+
+## SessionStorageInterface
+
+TBU
+
+## How To Implement
+
+1. `pocket/config/session.py` 내에 새로운 SessionType Enum 추가
+2. `pocket/config/session.py` 내에 새로운 SessionConfig 추가
+3. SessionStorageInterface 구현
+    - session storage가 초기화될 때 위에서 정의한 SessionConfig를 입력으로 받아야 한다.
+
+

hyperpocket/session/README.md

@@ -0,0 +1,61 @@
+# Session Storage
+
+Storage for saving user authentication(auth) sessions.
+
+## Current Supported Session Storages
+
+- [x] InMemory
+- [x] Redis
+- [ ] Postgres
+- [ ] Mysql
+- [ ] Mongodb
+
+## SessionKey
+
+Session key is a unique key to identify each authentication information.
+
+Generally this session key can be composed of the following three components:
+
+- Auth Provider : authentication provider
+- Thread ID : thread id
+- Profile : profile
+
+Each auth provider can only have one active session at a time.
+
+- For example, if a user already authenticated with a Slack token attempts to authenticate with OAuth, the previous
+  session will be invalidated.
+
+- Profile is a concept supported by Pocket that allows multiple profiles to exist within a single thread ID.
+
+- Using profiles, a single user can operate with multiple personas for various tasks.
+    - e.g., Reading messages from Group A’s Slack and summarizing them for Group B.
+
+## BaseSessionValue
+
+```python
+class BaseSessionValue(BaseModel):
+    auth_provider_name: str
+    auth_context: Optional[AuthContext] = None
+    scoped: bool
+    auth_scopes: Optional[Set[str]] = None
+    auth_resolve_uid: Optional[str] = None
+```
+
+A session contains the following basic information:
+
+- auth_provider_name: The name of the auth provider used for the current session.
+- auth_context: The actual session data contained in the auth context.
+- scoped: Indicates whether the current session is a scoped session.
+- auth_scopes: Auth scopes for the current session. This exists only for scoped sessions.
+- auth_resolve_uid: A UID for asynchronously checking whether the user has completed authentication.
+
+## SessionStorageInterface
+
+To Be Updated (TBU)
+
+## How to Implement
+
+1. Add the SessionType enum in `pocket/config/session.py`.
+2. Add the SessionConfig in `pocket/config/session.py`.
+3. Implement the SessionStorageInterface
+    - The session storage must be initialized with the SessionConfig defined above.

hyperpocket/session/__init__.py

@@ -0,0 +1,4 @@
+from hyperpocket.session.interface import SessionStorageInterface
+from hyperpocket.util.find_all_leaf_class_in_package import find_all_leaf_class_in_package
+
+SESSION_STORAGE_LIST = find_all_leaf_class_in_package("hyperpocket.session", SessionStorageInterface)

hyperpocket/session/in_memory.py

@@ -0,0 +1,76 @@
+from typing import Dict, List, Optional
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.config.session import SessionConfigInMemory
+from hyperpocket.config.session import SessionType
+from hyperpocket.session.interface import SessionStorageInterface, SESSION_KEY_DELIMITER, \
+    BaseSessionValue, V, K
+
+InMemorySessionKey = str
+InMemorySessionValue = BaseSessionValue
+
+
+class InMemorySessionStorage(SessionStorageInterface[InMemorySessionKey, InMemorySessionValue]):
+    # TODO(moon) : Force it to always take SessionConfig as an input
+    def __init__(self, session_config: SessionConfigInMemory):
+        super().__init__()
+        self.storage: Dict[InMemorySessionKey, InMemorySessionValue] = {}
+
+    @classmethod
+    def session_storage_type(cls) -> SessionType:
+        return SessionType.IN_MEMORY
+
+    def get(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> Optional[V]:
+        key = self._make_session_key(auth_provider, thread_id, profile)
+        return self.storage.get(key, None)
+
+    def set(self, auth_provider: AuthProvider,
+            thread_id: str,
+            profile: str,
+            auth_scopes: List[str],
+            auth_resolve_uid: Optional[str],
+            auth_context: Optional[AuthContext],
+            is_auth_scope_universal: bool, **kwargs) -> V:
+        key = self._make_session_key(auth_provider, thread_id, profile)
+        session = self._make_session(
+            auth_provider_name=auth_provider.name,
+            auth_scopes=auth_scopes,
+            auth_resolve_uid=auth_resolve_uid,
+            auth_context=auth_context,
+            is_auth_scope_universal=is_auth_scope_universal)
+
+        self.storage[key] = session
+        return session
+
+    def delete(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> bool:
+        key = self._make_session_key(auth_provider, thread_id, profile)
+        if key in self.storage:
+            self.storage.pop(key)
+            return True
+
+        return False
+
+    @staticmethod
+    def _make_session_key(auth_provider: AuthProvider, thread_id: str, profile: str) -> K:
+        return "{auth_provider}{delimiter}{thread_id}{delimiter}{profile}".format(
+            auth_provider=auth_provider.name,
+            thread_id=thread_id,
+            profile=profile,
+            delimiter=SESSION_KEY_DELIMITER,
+        )
+
+    @staticmethod
+    def _make_session(
+            auth_provider_name: str,
+            auth_scopes: List[str],
+            auth_context: AuthContext,
+            auth_resolve_uid: str,
+            is_auth_scope_universal: bool) -> V:
+        return InMemorySessionValue(
+            auth_provider_name=auth_provider_name,
+            auth_scopes=set(auth_scopes),
+            auth_context=auth_context,
+            auth_resolve_uid=auth_resolve_uid,
+            scoped=is_auth_scope_universal
+        )

hyperpocket/session/interface.py

@@ -0,0 +1,118 @@
+import datetime
+from abc import ABC, abstractmethod
+from typing import TypeVar, Generic, List, Set, Optional, Iterable
+
+from pydantic import BaseModel, Field
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.schema import AuthenticateRequest
+from hyperpocket.config.session import SessionType
+
+SESSION_NEAR_EXPIRE_SECONDS = 300
+SESSION_KEY_DELIMITER = "__"
+
+
+class BaseSessionValue(BaseModel):
+    auth_provider_name: str = Field(
+        description="The name of the authentication provider used to authenticate the current session")
+    auth_context: Optional[AuthContext] = Field(
+        default=None,
+        description="The authentication context containing the actual session details")
+    scoped: bool = Field(description="Indicates whether the current session is a scoped session")
+    auth_scopes: Optional[Set[str]] = Field(
+        default=None,
+        description="The authentication scopes of the current session, present only for scoped sessions")
+    auth_resolve_uid: Optional[str] = Field(
+        default=None,
+        description="A UID used to asynchronously verify whether the user has completed the authentication process")
+
+    def make_superset_auth_scope(
+            self,
+            other_scopes: Optional[Iterable[str]] = None) -> set[str]:
+        auth_scopes = self.auth_scopes or set()
+        other_scopes = other_scopes or set()
+        return auth_scopes.union(other_scopes)
+
+    def is_auth_applicable(self, auth_provider_name: str, auth_req: AuthenticateRequest) -> bool:
+        return self.auth_provider_name == auth_provider_name \
+            and (not self.scoped or self.auth_scopes.issuperset(auth_req.auth_scopes))
+
+    def is_near_expires(self) -> bool:
+        if self.auth_context.expires_at is not None:
+            now = datetime.datetime.now(tz=datetime.timezone.utc)
+            diff = self.auth_context.expires_at - now
+            if diff.total_seconds() < SESSION_NEAR_EXPIRE_SECONDS:
+                return True
+
+        return False
+
+
+K = TypeVar('K')
+V = TypeVar('V', bound=BaseSessionValue)
+
+
+class SessionStorageInterface(ABC, Generic[K, V]):
+    @abstractmethod
+    def get(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> V:
+        """
+        Get session
+
+        Args:
+            auth_provider (AuthProvider): auth provider
+            thread_id (str): thread id
+            profile (str): profile name
+
+        Returns:
+            V(BaseSessionValue): Session
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def set(self,
+            auth_provider: AuthProvider,
+            thread_id: str,
+            profile: str,
+            auth_scopes: List[str],
+            auth_resolve_uid: Optional[str],
+            auth_context: Optional[AuthContext],
+            is_auth_scope_universal: bool, **kwargs) -> V:
+        """
+        Set session, if a session doesn't exist, create new session
+        If set auth_resolve_uid is None and auth_context is not None, created session is regarded as active session.
+
+        Args:
+            auth_provider (AuthProvider): auth provider
+            thread_id (str): thread id
+            profile (str): profile name
+            auth_scopes (List[str]): auth scopes
+            auth_resolve_uid (str): a UID used to verify whether the user has completed the authentication process.
+                                    if set this value as None, it's regarded as active session
+            auth_context (Optional[AuthContext]): authentication context.
+                                    in pending session, this value is None. in active session this value shouldn't be None
+            is_auth_scope_universal(bool): a flag to determine whether the session is scoped or not
+
+        Returns:
+            V(BaseSessionValue): Updated session
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> bool:
+        """
+        Delete session
+
+        Args:
+            auth_provider (AuthProvider): auth provider
+            thread_id (str): thread id
+            profile (str): profile name
+
+        Returns:
+            bool: True if the session was deleted, False otherwise
+        """
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def session_storage_type(cls) -> SessionType:
+        raise NotImplementedError

hyperpocket/session/redis.py

@@ -0,0 +1,126 @@
+import json
+from typing import List, Optional, Any
+
+import redis
+
+from hyperpocket.auth import AuthProvider, AUTH_CONTEXT_MAP
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.config.session import SessionConfigRedis
+from hyperpocket.config.session import SessionType
+from hyperpocket.session.interface import SessionStorageInterface, SESSION_KEY_DELIMITER, \
+    BaseSessionValue, V, K
+
+RedisSessionKey = str
+RedisSessionValue = BaseSessionValue
+
+
+class RedisSessionStorage(SessionStorageInterface[RedisSessionKey, RedisSessionValue]):
+    def __init__(self, config: SessionConfigRedis):
+        super().__init__()
+        args = config.model_dump()
+        self.client = redis.StrictRedis(**args)
+
+    @classmethod
+    def session_storage_type(cls) -> SessionType:
+        return SessionType.REDIS
+
+    def get(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> Optional[V]:
+        key = self._make_session_key(auth_provider, thread_id, profile)
+        raw_session: Any = self.client.get(key)
+        if raw_session is None:
+            return None
+
+        session = self._deserialize(raw_session)
+        return session
+
+    def set(self, auth_provider: AuthProvider,
+            thread_id: str,
+            profile: str,
+            auth_scopes: List[str],
+            auth_resolve_uid: Optional[str],
+            auth_context: Optional[AuthContext],
+            is_auth_scope_universal: bool, **kwargs) -> V:
+        session = self._make_session(
+            auth_provider_name=auth_provider.name,
+            auth_scopes=auth_scopes,
+            auth_context=auth_context,
+            auth_resolve_uid=auth_resolve_uid,
+            is_auth_scope_universal=is_auth_scope_universal)
+
+        key = self._make_session_key(auth_provider, thread_id, profile)
+
+        raw_session = self._serialize(session)
+        self.client.set(key, raw_session)
+        return session
+
+    def delete(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> bool:
+        key = self._make_session_key(auth_provider, thread_id, profile)
+        return self.client.delete(key) == 1
+
+    @staticmethod
+    def _make_session_key(auth_provider: AuthProvider, thread_id: str, profile: str) -> K:
+        return "{auth_provider}{delimiter}{thread_id}{delimiter}{profile}".format(
+            auth_provider=auth_provider.name,
+            thread_id=thread_id,
+            profile=profile,
+            delimiter=SESSION_KEY_DELIMITER,
+        )
+
+    @staticmethod
+    def _make_session(
+            auth_provider_name: str,
+            auth_scopes: List[str],
+            auth_context: AuthContext,
+            auth_resolve_uid: str,
+            is_auth_scope_universal: bool) -> V:
+        return RedisSessionValue(
+            auth_provider_name=auth_provider_name,
+            auth_scopes=set(auth_scopes),
+            auth_context=auth_context,
+            auth_resolve_uid=auth_resolve_uid,
+            scoped=is_auth_scope_universal
+        )
+
+    @staticmethod
+    def _serialize(session: V) -> str:
+        auth_context_value, auth_context_type = None, None
+        if session.auth_context:
+            auth_context_value = session.auth_context.model_dump()
+            auth_context_type = session.auth_context.__class__.__name__
+
+        auth_scopes = session.auth_scopes
+        if auth_scopes:
+            auth_scopes = list(auth_scopes)
+
+        serialized = {"auth_context_value": auth_context_value,
+                      "auth_context_type": auth_context_type,
+                      "auth_provider_name": session.auth_provider_name,
+                      "scoped": session.scoped,
+                      "auth_scopes": auth_scopes,
+                      "auth_resolve_uid": session.auth_resolve_uid,
+                      }
+
+        return json.dumps(serialized)
+
+    @staticmethod
+    def _deserialize(raw_session: str) -> V:
+        session_dict = json.loads(raw_session)
+
+        auth_context = None
+        if auth_context_type_key := session_dict["auth_context_type"]:
+            auth_context_type = AUTH_CONTEXT_MAP[auth_context_type_key]
+            auth_context_value = session_dict["auth_context_value"]
+
+            auth_context = auth_context_type(**auth_context_value)
+
+        auth_scopes = session_dict["auth_scopes"]
+        if auth_scopes:
+            auth_scopes = set(auth_scopes)
+
+        return RedisSessionValue(
+            auth_provider_name=session_dict["auth_provider_name"],
+            auth_scopes=auth_scopes,
+            auth_resolve_uid=session_dict["auth_resolve_uid"],
+            scoped=session_dict["scoped"],
+            auth_context=auth_context
+        )

hyperpocket/session/tests/test_in_memory.py

@@ -0,0 +1,145 @@
+import unittest
+
+from hyperpocket.auth import AuthProvider, SlackTokenAuthContext
+from hyperpocket.config.session import SessionConfigInMemory
+from hyperpocket.session.in_memory import InMemorySessionStorage, InMemorySessionValue
+
+
+class TestInMemorySessionStorage(unittest.TestCase):
+    storage: InMemorySessionStorage
+    context: SlackTokenAuthContext
+
+    def setUp(self):
+        self.storage = InMemorySessionStorage(SessionConfigInMemory())
+        self.auth_context = SlackTokenAuthContext(
+            access_token="test",
+            description="test-description",
+            expires_at=None,
+            detail=None,
+        )
+
+    def tearDown(self):
+        del self.storage
+        del self.auth_context
+
+    def test_make_session_key(self):
+        key = self.storage._make_session_key(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile"
+        )
+
+        self.assertEqual(key, "SLACK__default_thread_id__default_profile")
+
+    def test_make_session(self):
+        session = self.storage._make_session(
+            auth_provider_name=AuthProvider.SLACK.name,
+            auth_scopes=["scope1", "scope2"],
+            auth_context=self.auth_context,
+            auth_resolve_uid="test-resolve-uid",
+            is_auth_scope_universal=True
+        )
+
+        # then
+        self.assertIsInstance(session, InMemorySessionValue)
+        self.assertEqual(session.auth_provider_name, AuthProvider.SLACK.name)
+        self.assertEqual(session.auth_context.access_token, "test")
+        self.assertEqual(session.auth_context.description, "test-description")
+
+    def test_set(self):
+        session = self.storage.set(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile",
+            auth_scopes=["scope1", "scope2"],
+            auth_resolve_uid="test-resolve-uid",
+            auth_context=self.auth_context,
+            is_auth_scope_universal=True
+        )
+
+        self.assertIsInstance(session, InMemorySessionValue)
+        self.assertEqual(session.auth_provider_name, AuthProvider.SLACK.name)
+        self.assertEqual(session.auth_context.access_token, self.auth_context.access_token)
+        self.assertEqual(session.auth_context.description, self.auth_context.description)
+
+    def test_get_existing_data(self):
+        # given
+        self.storage.set(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile",
+            auth_scopes=["scope1", "scope2"],
+            auth_resolve_uid="test-resolve-uid",
+            auth_context=self.auth_context,
+            is_auth_scope_universal=True
+        )
+
+        # when
+        session = self.storage.get(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile",
+        )
+
+        # then
+        self.assertIsInstance(session, InMemorySessionValue)
+        self.assertEqual(session.auth_provider_name, AuthProvider.SLACK.name)
+        self.assertEqual(session.auth_context.access_token, "test")
+        self.assertEqual(session.auth_context.description, "test-description")
+
+    def test_get_not_existing_data(self):
+        # when
+        session = self.storage.get(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile",
+        )
+
+        # then
+        self.assertIsNone(session)
+
+    def test_delete_existing_data(self):
+        # given
+        self.storage.set(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile",
+            auth_scopes=["scope1", "scope2"],
+            auth_resolve_uid="test-resolve-uid",
+            auth_context=self.auth_context,
+            is_auth_scope_universal=True
+        )
+
+        # when
+        before_session = self.storage.get(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile",
+        )
+
+        deleted = self.storage.delete(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile",
+        )
+
+        after_session = self.storage.get(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile",
+        )
+
+        # then
+        self.assertTrue(deleted)
+        self.assertIsNotNone(before_session)
+        self.assertIsNone(after_session)
+
+    def test_delete_not_existing_data(self):
+        deleted = self.storage.delete(
+            auth_provider=AuthProvider.SLACK,
+            thread_id="default_thread_id",
+            profile="default_profile",
+        )
+
+        # then
+        self.assertFalse(deleted)