hyperpocket 0.0.1__py3-none-any.whl

hyperpocket/auth/tests/test_slack_token_handler.py

@@ -0,0 +1,66 @@
+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/cli/__main__.py

@@ -0,0 +1,12 @@
+import click
+
+from hyperpocket.cli.pull import pull
+
+
+@click.group()
+def cli():
+    pass
+
+cli.add_command(pull)
+
+cli()

hyperpocket/cli/pull.py

@@ -0,0 +1,18 @@
+import pathlib
+from typing import Optional
+
+import click
+
+import hyperpocket.repository as repository
+
+
+@click.command()
+@click.argument('url', type=str)
+@click.option("--lockfile", envvar='PATHS', type=click.Path(exists=True))
+@click.option("--git-ref", type=str, default='HEAD')
+def pull(url: str, lockfile: Optional[pathlib.Path], git_ref: str):
+    if not lockfile:
+        lockfile = pathlib.Path.cwd() / 'pocket.lock'
+    if not lockfile.exists():
+        lockfile.touch()
+    repository.pull(repository.Lockfile(path=lockfile), url, git_ref)

hyperpocket/cli/sync.py

@@ -0,0 +1,17 @@
+import pathlib
+from typing import Optional
+
+import click
+
+import hyperpocket.repository as repository
+
+
+@click.command()
+@click.option("--lockfile", envvar='PATHS', type=click.Path(exists=True))
+@click.option("--force-update", type=str, default='HEAD')
+def sync(url: str, lockfile: Optional[pathlib.Path], force_update: bool):
+    if not lockfile:
+        lockfile = pathlib.Path.cwd() / 'pocket.lock'
+    if not lockfile.exists():
+        lockfile.touch()
+    repository.sync(repository.Lockfile(path=lockfile), force_update)

hyperpocket/config/__init__.py

@@ -0,0 +1,9 @@
+from hyperpocket.config.settings import config as _config
+from hyperpocket.config.settings import settings as _settings
+from hyperpocket.config.logger import pocket_logger as _pocket_logger
+
+config = _config
+secret = _settings
+pocket_logger = _pocket_logger
+
+__all__ = ["config", "secret", "pocket_logger"]

hyperpocket/config/auth.py

@@ -0,0 +1,36 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class BaseAuthConfig(BaseModel):
+    use_recommended_scope: bool = Field(default=True)
+
+
+class SlackAuthConfig(BaseAuthConfig):
+    client_id: str
+    client_secret: str
+
+
+class GoogleAuthConfig(BaseAuthConfig):
+    client_id: str
+    client_secret: str
+
+
+class GithubAuthConfig(BaseAuthConfig):
+    client_id: str
+    client_secret: str
+    
+class CalendlyAuthConfig(BaseAuthConfig):
+    client_id: str
+    client_secret: str
+
+class AuthConfig(BaseModel):
+    slack: Optional[SlackAuthConfig] = None
+    google: Optional[GoogleAuthConfig] = None
+    github: Optional[GithubAuthConfig] = None
+    calendly: Optional[CalendlyAuthConfig] = None
+    use_prebuilt_auth: bool = Field(default=True)
+
+
+DefaultAuthConfig = AuthConfig()

hyperpocket/config/git.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class GithubConfig(BaseModel):
+    github_token: Optional[str] = None
+    app_id: Optional[str] = None
+    app_private_key: Optional[str] = None
+    app_installation_id: Optional[str] = None
+
+
+class GitConfig(BaseModel):
+    github: GithubConfig
+
+
+DefaultGitConfig = GitConfig(github=GithubConfig())

hyperpocket/config/logger.py

@@ -0,0 +1,81 @@
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+import hyperpocket
+from hyperpocket.config.settings import config
+
+class ColorFormatter(logging.Formatter):
+    """Custom formatter to add colors based on log level."""
+    # ANSI escape codes for text colors
+    LEVEL_COLORS = {
+        logging.DEBUG: "\033[36m",     # Cyan
+        logging.INFO: "\033[32m",      # Green
+        logging.WARNING: "\033[33m",   # Yellow
+        logging.ERROR: "\033[31m",     # Red
+        logging.CRITICAL: "\033[35m",  # Magenta
+    }
+    RESET = "\033[0m"
+
+    def format(self, record):
+        log_color = self.LEVEL_COLORS.get(record.levelno, self.RESET)
+        message = super().format(record)
+        return f"{log_color}{message}{self.RESET}"
+
+
+
+def get_logger():
+    # init log file
+    package_path = Path(os.path.dirname(hyperpocket.__file__))
+    log_dir = package_path / ".log"
+    os.makedirs(log_dir, exist_ok=True)
+    log_file = log_dir / "pocket.log"
+    if not log_file.exists():
+        print(f"created log file in {log_file}")
+        with open(log_file, "w"):
+            pass
+
+    # set log level
+    log_level = logging.INFO
+    logger = logging.getLogger("pocket_logger")
+    if config.log_level.lower() == "debug":
+        log_level = logging.DEBUG
+    elif config.log_level.lower() == "info":
+        log_level = logging.INFO
+    elif config.log_level.lower() == "warning":
+        log_level = logging.WARNING
+    elif config.log_level.lower() == "error":
+        log_level = logging.ERROR
+    elif config.log_level.lower() == "critical":
+        log_level = logging.CRITICAL
+    elif config.log_level.lower() == "fatal":
+        log_level = logging.FATAL
+
+    # set formatter
+    logger.setLevel(log_level)
+    color_formatter = ColorFormatter("[%(asctime)s] [%(levelname)s] [%(processName)s(%(process)d):%(threadName)s(%(thread)d)] [%(name)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S")
+    formatter = logging.Formatter(
+        "[%(asctime)s] [%(levelname)s] [%(processName)s(%(process)d):%(threadName)s(%(thread)d)] [%(name)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+
+    # add console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(log_level)  # 콘솔 출력 레벨 설정
+    console_handler.setFormatter(color_formatter)
+    logger.addHandler(console_handler)
+
+    # add rotating file handler
+    file_handler = RotatingFileHandler(
+        log_file, maxBytes=5 * 1024 * 1024, backupCount=100  # 파일 크기 5MB, 백업 파일 3개
+    )
+    file_handler.setLevel(logging.DEBUG)  # 파일 출력 레벨 설정
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+
+    return logger
+
+
+pocket_logger = get_logger()

hyperpocket/config/session.py

@@ -0,0 +1,35 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class SessionType(Enum):
+    IN_MEMORY = "in_memory"
+    REDIS = "redis"
+
+
+class SessionConfigInMemory(BaseModel):
+    pass
+
+
+class SessionConfigRedis(BaseModel):
+    class Config:
+        extra = "allow"
+
+    host: str = Field(default="localhost")
+    port: int = Field(default=6379)
+    db: int = Field(default=0)
+
+
+class SessionConfig(BaseModel):
+    session_type: SessionType
+    in_memory: Optional[SessionConfigInMemory] = Field(default_factory=SessionConfigInMemory)
+    redis: Optional[SessionConfigRedis] = Field(default_factory=SessionConfigRedis)
+
+
+DefaultSessionConfig = SessionConfig(
+    session_type=SessionType.IN_MEMORY,
+    in_memory=SessionConfigInMemory(),
+    redis=SessionConfigRedis()
+)

hyperpocket/config/settings.py

@@ -0,0 +1,62 @@
+import os
+from pathlib import Path
+from typing import Literal
+
+from dynaconf import Dynaconf
+from pydantic import BaseModel
+
+from hyperpocket.config.auth import AuthConfig, DefaultAuthConfig
+from hyperpocket.config.git import DefaultGitConfig, GitConfig
+from hyperpocket.config.session import DefaultSessionConfig, SessionConfig
+
+pocket_root = Path.home() / ".pocket"
+if not pocket_root.exists():
+    os.makedirs(pocket_root)
+settings_path = pocket_root / "settings.toml"
+if not settings_path.exists():
+    with open(settings_path, "w"):
+        pass
+secret_path = pocket_root / ".secrets.toml"
+if not secret_path.exists():
+    with open(secret_path, "w"):
+        pass
+toolpkg_path = pocket_root / "toolpkg"
+if not toolpkg_path.exists():
+    os.makedirs(toolpkg_path)
+
+settings = Dynaconf(
+    envvar_prefix="POCKET",
+    settings_files=[settings_path, secret_path],
+)
+
+for key, value in os.environ.items():
+    if settings.get(key) is None:
+        settings[key] = value
+
+
+class Config(BaseModel):
+    internal_server_port: int = 8000
+    enable_local_callback_proxy: bool = True
+    public_hostname: str = "localhost"
+    public_server_protocol: str = "https"
+    public_server_port: int = 8001
+    callback_url_rewrite_prefix: str = "proxy"  # should not start with a slash
+    log_level: str = "INFO"
+    auth: AuthConfig = DefaultAuthConfig
+    git: GitConfig = DefaultGitConfig
+    session: SessionConfig = DefaultSessionConfig
+
+    @property
+    def internal_base_url(self):
+        return f"http://localhost:{self.internal_server_port}"
+
+    @property
+    def public_base_url(self):
+        if self.public_server_protocol == 'https' and self.public_server_port == 443:
+            return f"{self.public_server_protocol}://{self.public_hostname}"
+        elif self.public_server_protocol == 'http' and self.public_server_port == 80:
+            return f"{self.public_server_protocol}://{self.public_hostname}"
+        return f"{self.public_server_protocol}://{self.public_hostname}:{self.public_server_port}"
+
+
+config: Config = Config.model_validate({k.lower(): v for k, v in settings.items()})

hyperpocket/curated_tools.py

@@ -0,0 +1,10 @@
+from hyperpocket.tool import from_git
+
+SLACK = [
+    from_git("https://github.com/vessl-ai/tool-calling", "main", "examples/slack-get-message"),
+    from_git("https://github.com/vessl-ai/tool-calling", "main", "examples/slack-post-message")
+]
+
+LINEAR = [
+    from_git("https://github.com/vessl-ai/tool-calling", "main", "examples/linear-get-issues"),
+]

hyperpocket/external/__init__.py

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

hyperpocket/external/github_client.py

@@ -0,0 +1,19 @@
+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/futures/__init__.py

@@ -0,0 +1,7 @@
+from hyperpocket.futures.futurestore import FutureStore as _FutureStore
+
+FutureStore = _FutureStore()
+
+__all__ = [
+    'FutureStore',
+]

hyperpocket/futures/futurestore.py

@@ -0,0 +1,48 @@
+import asyncio
+import enum
+from typing import Any
+
+from hyperpocket.config import pocket_logger
+
+
+class FutureData:
+    future: asyncio.Future
+    data: dict
+
+    def __init__(self, future: asyncio.Future, data: dict):
+        self.future = future
+        self.data = data
+
+
+class FutureStore(object):
+    futures: dict[str, FutureData]
+
+    def __init__(self):
+        self.futures = dict()
+
+    def create_future(self, uid: str, data: dict = None) -> FutureData:
+        if future := self.get_future(uid) is not None:
+            pocket_logger.info(
+                f"the future already exists. the existing future is returned. uid: {uid}")
+            return future
+
+        loop = asyncio.get_running_loop()
+        future = loop.create_future()
+        future_data = FutureData(future=future, data=data)
+
+        self.futures[uid] = future_data
+
+        return future_data
+
+    def get_future(self, uid: str) -> FutureData:
+        return self.futures.get(uid, None)
+
+    def resolve_future(self, uid: str, value: Any):
+        future_data = self.futures.get(uid)
+        if not future_data:
+            raise ValueError(f'Future not found for uid={uid}')
+        if not future_data.future.done():
+            future_data.future.set_result(value)
+
+    def delete_future(self, uid: str):
+        self.futures.pop(uid, None)