hyperpocket 0.0.2__py3-none-any.whl → 0.1.8__py3-none-any.whl

hyperpocket/auth/tests/test_slack_token_handler.py

@@ -1,66 +0,0 @@
-from unittest.async_case import IsolatedAsyncioTestCase
-from urllib.parse import urlparse, parse_qs
-
-from hyperpocket.auth import SlackTokenAuthContext
-from hyperpocket.auth.slack.token_handler import SlackTokenAuthHandler
-from hyperpocket.auth.slack.token_schema import SlackTokenRequest
-from hyperpocket.futures import FutureStore
-
-
-class TestSlackTokenAuthHandler(IsolatedAsyncioTestCase):
-
-    async def asyncSetUp(self):
-        self.handler: SlackTokenAuthHandler = SlackTokenAuthHandler()
-        self.auth_req = SlackTokenRequest()
-
-    async def test_make_auth_url(self):
-        auth_url = self.handler._make_auth_url(
-            req=self.auth_req,
-            redirect_uri="http://test-redirect-uri.com",
-            state="test-future-id"
-        )
-        parsed = urlparse(auth_url)
-        query_params = parse_qs(parsed.query)
-        base_url = f"{parsed.scheme}://{parsed.netloc}{parsed.path}"
-
-        # then
-        self.assertEqual(base_url, self.handler._TOKEN_URL)
-        self.assertEqual(query_params["state"][0], "test-future-id")
-        self.assertEqual(query_params["redirect_uri"][0], "http://test-redirect-uri.com")
-
-    async def test_prepare(self):
-        # when
-        prepare: str = self.handler.prepare(
-            auth_req=self.auth_req,
-            thread_id="test-prepare-thread-id",
-            profile="test-prepare-profile",
-            future_uid="test-prepare-future-uid",
-        )
-        auth_url = prepare.removeprefix("User needs to authenticate using the following URL:").strip()
-        future_data = FutureStore.get_future( uid="test-prepare-future-uid")
-
-        # then
-        self.assertTrue(auth_url.startswith(self.handler._TOKEN_URL))
-        self.assertIsNotNone(future_data)
-        self.assertEqual(future_data.data["thread_id"], "test-prepare-thread-id")
-        self.assertEqual(future_data.data["profile"], "test-prepare-profile")
-        self.assertFalse(future_data.future.done())
-
-    async def test_authenticate(self):
-        self.handler.prepare(
-            auth_req=self.auth_req,
-            thread_id="test-thread-id",
-            profile="test-profile",
-            future_uid="test-future-uid"
-        )
-        future_data = FutureStore.get_future( uid="test-future-uid")
-        future_data.future.set_result("test-token")
-
-        response: SlackTokenAuthContext = await self.handler.authenticate(
-            auth_req=self.auth_req,
-            future_uid="test-future-uid"
-        )
-
-        self.assertIsInstance(response, SlackTokenAuthContext)
-        self.assertEqual(response.access_token, "test-token")
-        self.assertIsNone(response.expires_at)

hyperpocket/external/__init__.py

@@ -1,7 +0,0 @@
-from hyperpocket.external.github_client import github_instance
-
-github = github_instance()
-
-__all__ = [
-    "github",
-]

hyperpocket/external/github_client.py

@@ -1,19 +0,0 @@
-from github import Auth, Github, GithubIntegration
-
-from hyperpocket.config import config
-
-_github = None
-
-
-def github_instance() -> Github:
-    global _github
-    if _github is None:
-        if config.git.github.github_token:
-            _github = Github(auth=Auth.Token(config.git.github.github_token))
-        elif config.git.github.app_id:
-            auth = Auth.AppAuth(config.git.github.app_id, config.git.github.app_private_key)
-            gi = GithubIntegration(auth=auth)
-            _github = gi.get_github_for_installation(config.git.github.app_installation_id)
-        else:
-            _github = Github()
-    return _github

hyperpocket/session/README.KR.md

@@ -1,62 +0,0 @@
-# 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/tests/test_in_memory.py

@@ -1,145 +0,0 @@
-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)

hyperpocket/session/tests/test_redis.py

@@ -1,151 +0,0 @@
-import unittest
-
-from hyperpocket.auth import AuthProvider, SlackTokenAuthContext
-from hyperpocket.config.session import SessionConfigRedis
-from hyperpocket.session.in_memory import InMemorySessionValue
-from hyperpocket.session.redis import RedisSessionStorage, RedisSessionValue
-
-
-class TestRedisSessionStorage(unittest.TestCase):
-    storage: RedisSessionStorage
-    context: SlackTokenAuthContext
-
-    def setUp(self):
-        self.storage = RedisSessionStorage(SessionConfigRedis(
-            host="localhost",
-            port=6379,
-            db="9"
-        ))
-        self.storage.client.flushdb()
-
-        self.auth_context = SlackTokenAuthContext(
-            access_token="test",
-            description="test-description",
-            expires_at=None,
-            detail=None,
-        )
-
-    def tearDown(self):
-        self.storage.client.flushdb()
-
-    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, RedisSessionValue)
-        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)

hyperpocket/tests/test_pocket.py

@@ -1,116 +0,0 @@
-from pathlib import Path
-from unittest.async_case import IsolatedAsyncioTestCase
-
-from pydantic import BaseModel
-
-from hyperpocket import Pocket
-from hyperpocket.config import config
-from hyperpocket.tool import from_local, from_git
-
-
-class TestPocket(IsolatedAsyncioTestCase):
-
-    async def asyncSetUp(self):
-        self.profile = "test-profile"
-        self.thread_id = "test_thread_id"
-
-        config.public_server_port = "https"
-        config.public_hostname = "localhost"
-        config.public_server_port = 8001
-        config.internal_server_port = 8000
-        config.enable_local_callback_proxy = True
-
-        self.pocket = Pocket(
-            tools=[
-                from_git("https://github.com/vessl-ai/hyperawesometools", "main", "managed-tools/simple-echo-tool"),
-                self.add,
-                self.add_pydantic_args
-            ],
-        )
-
-    async def test_function_tool(self):
-        # given
-        tool_name = "add"
-
-        # when
-        result = await self.pocket.ainvoke(
-            tool_name=tool_name,
-            body={
-                "a": 1,
-                "b": 3
-            },
-            thread_id=self.thread_id,
-            profile=self.profile,
-        )
-
-        # then
-        self.assertEqual(result, "4")
-
-    async def test_pydantic_arg_function_tool(self):
-        # given
-        tool_name = "add_pydantic_args"
-
-        # when
-        result = await self.pocket.ainvoke(
-            tool_name=tool_name,
-            body={
-                "a": {
-                    "first": 1
-                },
-                "b": {
-                    "second": 3
-                }
-            },
-            thread_id=self.thread_id,
-            profile=self.profile,
-        )
-
-        # then
-        self.assertEqual(result, "4")
-
-    async def test_wasm_tool(self):
-        # given
-        tool_name = "simple_echo_text"
-
-        # when
-        result = await self.pocket.ainvoke(
-            tool_name=tool_name,
-            body={
-                "text": "test"
-            },
-            thread_id=self.thread_id,
-            profile=self.profile,
-        )
-
-        # then
-        self.assertTrue(result.startswith("echo message : test"))
-
-    @staticmethod
-    def add(a: int, b: int) -> int:
-        """
-        Add two numbers
-
-        Args:
-            a(int): first number
-            b(int): second number
-
-        """
-
-        return a + b
-
-    class FirstNumber(BaseModel):
-        first: int
-
-    class SecondNumber(BaseModel):
-        second: int
-
-    @staticmethod
-    def add_pydantic_args(a: FirstNumber, b: SecondNumber):
-        """
-        Add two numbers
-
-        Args:
-            a(FirstNumber): first number
-            b(SecondNumber): second number
-        """
-        return a.first + b.second