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

hyperpocket/cli/__main__.py

@@ -1,19 +1,21 @@
 import click
 
+from hyperpocket.cli.auth import create_token_auth_template
+from hyperpocket.cli.eject import eject
 from hyperpocket.cli.pull import pull
 from hyperpocket.cli.sync import sync
-from hyperpocket.cli.eject import eject
-from hyperpocket.cli.auth import create_token_auth_template
 
 
 @click.group()
 def cli():
     pass
 
+
 @click.group()
 def devtool():
     pass
 
+
 cli.add_command(devtool)
 devtool.add_command(create_token_auth_template)
 

hyperpocket/cli/auth.py

@@ -1,23 +1,36 @@
 import os
-import click
 from pathlib import Path
-from hyperpocket.cli.codegen.auth import get_server_auth_token_template, get_auth_context_template, get_auth_token_context_template, get_auth_token_handler_template, get_auth_token_schema_template
+
+import click
+
+from hyperpocket.cli.codegen.auth import (
+    get_auth_context_template,
+    get_auth_token_context_template,
+    get_auth_token_handler_template,
+    get_auth_token_schema_template,
+    get_server_auth_token_template,
+)
+
 
 @click.command()
-@click.argument('service_name', type=str)
+@click.argument("service_name", type=str)
 def create_token_auth_template(service_name):
     ## Validate service_name
-    if not service_name.islower() or not service_name.replace('_', '').isalpha():
-        raise ValueError("service_name must be lowercase and contain only letters and underscores")
-    
+    if not service_name.islower() or not service_name.replace("_", "").isalpha():
+        raise ValueError(
+            "service_name must be lowercase and contain only letters and underscores"
+        )
+
     capitliazed_service_name = service_name.capitalize()
-    if '_' in service_name:
-        capitliazed_service_name = ''.join([word.capitalize() for word in service_name.split('_')])
-    
+    if "_" in service_name:
+        capitliazed_service_name = "".join(
+            [word.capitalize() for word in service_name.split("_")]
+        )
+
     ## Get the current working directory
     cwd = Path.cwd()
     parent_path = cwd.parent
-    
+
     generate_server_auth(service_name, parent_path)
     generate_hyperpocket_auth_dir(service_name, parent_path)
     generate_auth_context(service_name, capitliazed_service_name, parent_path)
@@ -26,58 +39,76 @@ def create_token_auth_template(service_name):
     generate_auth_token_schema(service_name, capitliazed_service_name, parent_path)
     ##TODO: Add service to hyperpocket/auth/provider
 
+
 def generate_server_auth(service_name, parent_path):
     print(f"Generating server/auth for '{service_name}'.")
-    output_from_parsed_template = get_server_auth_token_template().render(service_name=service_name)
-    output_path = parent_path / f'hyperpocket/hyperpocket/server/auth/{service_name}.py'
+    output_from_parsed_template = get_server_auth_token_template().render(
+        service_name=service_name
+    )
+    output_path = parent_path / f"hyperpocket/hyperpocket/server/auth/{service_name}.py"
     with open(output_path, "w") as f:
         f.write(output_from_parsed_template)
 
+
 def generate_hyperpocket_auth_dir(service_name, parent_path):
-    if not os.path.exists(parent_path / f'hyperpocket/hyperpocket/auth/{service_name}'):
-        os.makedirs(parent_path / f'hyperpocket/hyperpocket/auth/{service_name}')
-    
-    output_path = parent_path / f'hyperpocket/hyperpocket/auth/{service_name}/__init__.py'
-    with open(output_path, "w") as f:
+    if not os.path.exists(parent_path / f"hyperpocket/hyperpocket/auth/{service_name}"):
+        os.makedirs(parent_path / f"hyperpocket/hyperpocket/auth/{service_name}")
+
+    output_path = (
+        parent_path / f"hyperpocket/hyperpocket/auth/{service_name}/__init__.py"
+    )
+    with open(output_path, "w"):
         pass
 
+
 def generate_auth_context(service_name, capitliazed_service_name, parent_path):
     print(f"Generating auth/context for '{service_name}'.")
     output_from_parsed_template = get_auth_context_template().render(
-        caplitalized_service_name=capitliazed_service_name, 
-        upper_service_name=service_name.upper()
+        caplitalized_service_name=capitliazed_service_name,
+        upper_service_name=service_name.upper(),
+    )
+    output_path = (
+        parent_path / f"hyperpocket/hyperpocket/auth/{service_name}/context.py"
     )
-    output_path = parent_path / f'hyperpocket/hyperpocket/auth/{service_name}/context.py'
     with open(output_path, "w") as f:
         f.write(output_from_parsed_template)
 
+
 def generate_auth_token_context(service_name, capitliazed_service_name, parent_path):
     print(f"Generating auth/token context for '{service_name}'.")
     output_from_parsed_template = get_auth_token_context_template().render(
-        service_name = service_name,
-        caplitalized_service_name=capitliazed_service_name, 
+        service_name=service_name,
+        caplitalized_service_name=capitliazed_service_name,
+    )
+    output_path = (
+        parent_path / f"hyperpocket/hyperpocket/auth/{service_name}/token_context.py"
     )
-    output_path = parent_path / f'hyperpocket/hyperpocket/auth/{service_name}/token_context.py'
     with open(output_path, "w") as f:
         f.write(output_from_parsed_template)
 
+
 def generate_auth_token_handler(service_name, capitliazed_service_name, parent_path):
     print(f"Generating auth/token handler for '{service_name}'.")
     output_from_parsed_template = get_auth_token_handler_template().render(
-        service_name = service_name,
-        auth_handler_name = service_name.replace('_','-'),
+        service_name=service_name,
+        auth_handler_name=service_name.replace("_", "-"),
         caplitalized_service_name=capitliazed_service_name,
-        upper_service_name=service_name.upper()
+        upper_service_name=service_name.upper(),
+    )
+    output_path = (
+        parent_path / f"hyperpocket/hyperpocket/auth/{service_name}/token_handler.py"
     )
-    output_path = parent_path / f'hyperpocket/hyperpocket/auth/{service_name}/token_handler.py'
     with open(output_path, "w") as f:
         f.write(output_from_parsed_template)
 
+
 def generate_auth_token_schema(service_name, capitliazed_service_name, parent_path):
     print(f"Generating auth/token schema for '{service_name}'.")
     output_from_parsed_template = get_auth_token_schema_template().render(
         caplitalized_service_name=capitliazed_service_name,
     )
-    output_path = parent_path / f'hyperpocket/hyperpocket/auth/{service_name}/token_schema.py'
+    output_path = (
+        parent_path / f"hyperpocket/hyperpocket/auth/{service_name}/token_schema.py"
+    )
     with open(output_path, "w") as f:
         f.write(output_from_parsed_template)

hyperpocket/cli/codegen/auth/auth_context_template.py

@@ -1,7 +1,8 @@
 from jinja2 import Template
 
+
 def get_auth_context_template() -> Template:
-    return Template('''
+    return Template("""
 from hyperpocket.auth.context import AuthContext
 class {{ caplitalized_service_name }}AuthContext(AuthContext):
     _ACCESS_TOKEN_KEY: str = "{{ upper_service_name }}_TOKEN"
@@ -13,4 +14,4 @@ class {{ caplitalized_service_name }}AuthContext(AuthContext):
         return {
             f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
         }
-''')
+""")

hyperpocket/cli/codegen/auth/auth_token_context_template.py

@@ -1,7 +1,8 @@
 from jinja2 import Template
 
+
 def get_auth_token_context_template() -> Template:
-    return Template('''
+    return Template("""
 from hyperpocket.auth.{{ service_name }}.context import {{ caplitalized_service_name }}AuthContext
 from hyperpocket.auth.{{ service_name }}.token_schema import {{ caplitalized_service_name }}TokenResponse
 class {{ caplitalized_service_name }}TokenAuthContext({{ caplitalized_service_name }}AuthContext):
@@ -13,4 +14,4 @@ class {{ caplitalized_service_name }}TokenAuthContext({{ caplitalized_service_na
             description=description,
             expires_at=None
         )
-''')
+""")

hyperpocket/cli/codegen/auth/auth_token_handler_template.py

@@ -1,7 +1,8 @@
 from jinja2 import Template
 
+
 def get_auth_token_handler_template() -> Template:
-    return Template('''
+    return Template("""
 from typing import Optional
 from urllib.parse import urljoin, urlencode
 
@@ -19,7 +20,7 @@ class {{ caplitalized_service_name }}TokenAuthHandler(AuthHandlerInterface):
     description: str = "This handler is used to authenticate users using the {{ caplitalized_service_name }} token."
     scoped: bool = False
 
-    _TOKEN_URL: str = urljoin(config.public_base_url + "/", f"{config.callback_url_rewrite_prefix}/auth/token")
+    _TOKEN_URL: str = urljoin(config().public_base_url + "/", f"{config().callback_url_rewrite_prefix}/auth/token")
 
     @staticmethod
     def provider() -> AuthProvider:
@@ -32,8 +33,8 @@ class {{ caplitalized_service_name }}TokenAuthHandler(AuthHandlerInterface):
     def prepare(self, auth_req: {{ caplitalized_service_name }}TokenRequest, thread_id: str, profile: str,
                 future_uid: str, *args, **kwargs) -> str:
         redirect_uri = urljoin(
-            config.public_base_url + "/",
-            f"{config.callback_url_rewrite_prefix}/auth/{{ service_name }}/token/callback",
+            config().public_base_url + "/",
+            f"{config().callback_url_rewrite_prefix}/auth/{{ service_name }}/token/callback",
         )
         url = self._make_auth_url(auth_req=auth_req, redirect_uri=redirect_uri, state=future_uid)
         FutureStore.create_future(future_uid, data={
@@ -66,4 +67,4 @@ class {{ caplitalized_service_name }}TokenAuthHandler(AuthHandlerInterface):
 
     def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> {{ caplitalized_service_name }}TokenRequest:
         return {{ caplitalized_service_name }}TokenRequest()
-''')
+""")

hyperpocket/cli/codegen/auth/auth_token_schema_template.py

@@ -1,7 +1,8 @@
 from jinja2 import Template
 
+
 def get_auth_token_schema_template() -> Template:
-    return Template('''
+    return Template("""
 from typing import List, Optional
 from pydantic import BaseModel
 from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
@@ -9,4 +10,4 @@ class {{ caplitalized_service_name }}TokenRequest(AuthenticateRequest):
     pass
 class {{ caplitalized_service_name }}TokenResponse(AuthenticateResponse):
     access_token: str
-''')
+""")

hyperpocket/cli/codegen/auth/server_auth_template.py

@@ -1,7 +1,8 @@
 from jinja2 import Template
 
+
 def get_server_auth_token_template() -> Template:
-    return Template('''
+    return Template("""
 from fastapi import APIRouter
 from starlette.responses import HTMLResponse
 from hyperpocket.futures import FutureStore
@@ -15,4 +16,4 @@ async def {{ service_name }}_token_callback(state: str, token: str):
     except ValueError:
         return HTMLResponse(content="failed")
     return HTMLResponse(content="success")                    
-''')
+""")

hyperpocket/cli/pull.py

@@ -7,12 +7,12 @@ 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')
+@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'
+        lockfile = pathlib.Path.cwd() / "pocket.lock"
     if not lockfile.exists():
         lockfile.touch()
-    repository.pull(repository.Lockfile(path=lockfile), url, git_ref)
+    repository.pull(repository.Lockfile(path=lockfile), url, git_ref)

hyperpocket/config/__init__.py

@@ -1,9 +1,4 @@
-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
+from hyperpocket.config.logger import pocket_logger
+from hyperpocket.config.settings import config
 
-config = _config
-secret = _settings
-pocket_logger = _pocket_logger
-
-__all__ = ["config", "secret", "pocket_logger"]
+__all__ = ["config", "pocket_logger"]

hyperpocket/config/auth.py

@@ -20,11 +20,13 @@ class GoogleAuthConfig(BaseAuthConfig):
 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

hyperpocket/config/logger.py

@@ -6,14 +6,16 @@ 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.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"
@@ -24,7 +26,6 @@ class ColorFormatter(logging.Formatter):
         return f"{log_color}{message}{self.RESET}"
 
 
-
 def get_logger():
     # init log file
     package_path = Path(os.path.dirname(hyperpocket.__file__))
@@ -39,26 +40,28 @@ def get_logger():
     # set log level
     log_level = logging.INFO
     logger = logging.getLogger("pocket_logger")
-    if config.log_level.lower() == "debug":
+    if config().log_level.lower() == "debug":
         log_level = logging.DEBUG
-    elif config.log_level.lower() == "info":
+    elif config().log_level.lower() == "info":
         log_level = logging.INFO
-    elif config.log_level.lower() == "warning":
+    elif config().log_level.lower() == "warning":
         log_level = logging.WARNING
-    elif config.log_level.lower() == "error":
+    elif config().log_level.lower() == "error":
         log_level = logging.ERROR
-    elif config.log_level.lower() == "critical":
+    elif config().log_level.lower() == "critical":
         log_level = logging.CRITICAL
-    elif config.log_level.lower() == "fatal":
+    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")
+    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"
+        datefmt="%Y-%m-%d %H:%M:%S",
     )
 
     # add console handler
@@ -69,7 +72,9 @@ def get_logger():
 
     # add rotating file handler
     file_handler = RotatingFileHandler(
-        log_file, maxBytes=5 * 1024 * 1024, backupCount=100  # 파일 크기 5MB, 백업 파일 3개
+        log_file,
+        maxBytes=5 * 1024 * 1024,
+        backupCount=100,  # 파일 크기 5MB, 백업 파일 3개
     )
     file_handler.setLevel(logging.DEBUG)  # 파일 출력 레벨 설정
     file_handler.setFormatter(formatter)

hyperpocket/config/session.py

@@ -24,12 +24,14 @@ class SessionConfigRedis(BaseModel):
 
 class SessionConfig(BaseModel):
     session_type: SessionType
-    in_memory: Optional[SessionConfigInMemory] = Field(default_factory=SessionConfigInMemory)
+    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()
+    redis=SessionConfigRedis(),
 )

hyperpocket/config/settings.py

@@ -43,7 +43,7 @@ class Config(BaseModel):
     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"
+    log_level: str = "info"
     auth: AuthConfig = DefaultAuthConfig
     session: SessionConfig = DefaultSessionConfig
     tool_vars: dict[str, str] = Field(default_factory=dict)
@@ -61,4 +61,21 @@ class Config(BaseModel):
         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()})
+def _dynaconf_to_config(s) -> dict:
+    values = dict()
+    for k, v in s.items():
+        if getattr(v, "items", None) is not None:
+            values[str(k).lower()] = _dynaconf_to_config(v)
+        else:
+            values[str(k).lower()] = v
+    return values
+
+
+_config = None
+
+
+def config() -> Config:
+    global _config
+    if _config is None:
+        _config = Config.model_validate(_dynaconf_to_config(settings))
+    return _config

hyperpocket/futures/__init__.py

@@ -3,5 +3,5 @@ from hyperpocket.futures.futurestore import FutureStore as _FutureStore
 FutureStore = _FutureStore()
 
 __all__ = [
-    'FutureStore',
+    "FutureStore",
 ]

hyperpocket/futures/futurestore.py

@@ -22,7 +22,8 @@ class FutureStore(object):
     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}")
+                f"the future already exists. the existing future is returned. uid: {uid}"
+            )
             return future
 
         loop = asyncio.get_running_loop()
@@ -39,7 +40,7 @@ class FutureStore(object):
     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}')
+            raise ValueError(f"Future not found for uid={uid}")
         if not future_data.future.done():
             future_data.future.set_result(value)