hyperpocket 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

hyperpocket/auth/reddit/oauth2_handler.py

@@ -53,7 +53,7 @@ class RedditOAuth2AuthHandler(AuthHandlerInterface):
             config().public_base_url + "/",
             f"{config().callback_url_rewrite_prefix}/auth/reddit/oauth2/callback",
         )
-        print(f"redirect_uri: {redirect_uri}")
+
         auth_url = self._make_auth_url(
             req=auth_req, redirect_uri=redirect_uri, state=future_uid
         )

hyperpocket/auth/slack/oauth2_handler.py

@@ -59,7 +59,7 @@ class SlackOAuth2AuthHandler(AuthHandlerInterface):
             config().public_base_url + "/",
             f"{config().callback_url_rewrite_prefix}/auth/slack/oauth2/callback",
         )
-        print(f"redirect_uri: {redirect_uri}")
+
         auth_url = self._make_auth_url(
             req=auth_req, redirect_uri=redirect_uri, state=future_uid
         )

hyperpocket/cli/__main__.py

@@ -1,10 +1,11 @@
 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_token import create_token_auth_template
+from hyperpocket.cli.auth_oauth2 import create_oauth2_auth_template
 
 @click.group()
 def cli():
@@ -18,6 +19,7 @@ def devtool():
 
 cli.add_command(devtool)
 devtool.add_command(create_token_auth_template)
+devtool.add_command(create_oauth2_auth_template)
 
 cli.add_command(pull)
 cli.add_command(sync)

hyperpocket/cli/auth_oauth2.py

@@ -0,0 +1,90 @@
+import os
+import click
+from pathlib import Path
+from hyperpocket.cli.codegen.auth import get_auth_context_template, get_auth_oauth2_context_template, get_auth_oauth2_handler_template, get_auth_oauth2_schema_template, get_server_auth_oauth2_template
+
+@click.command()
+@click.argument('service_name', type=str)
+@click.option('--force', is_flag=True, default=False)
+def create_oauth2_auth_template(service_name, force):
+    ## 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")
+    
+    capitliazed_service_name = service_name.capitalize()
+    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, force)
+    generate_hyperpocket_auth_dir(service_name, parent_path, force)
+    generate_auth_context(service_name, capitliazed_service_name, parent_path, force)
+    generate_auth_oauth2_context(service_name, capitliazed_service_name, parent_path, force)
+    generate_auth_oauth2_handler(service_name, capitliazed_service_name, parent_path, force)
+    generate_auth_oauth2_schema(service_name, capitliazed_service_name, parent_path, force)
+    ##TODO: Add service to hyperpocket/auth/provider
+
+def generate_server_auth(service_name, parent_path, force):
+    print(f"Generating server/auth for '{service_name}'.")
+    output_from_parsed_template = get_server_auth_oauth2_template().render(service_name=service_name)
+    output_path = parent_path / f'hyperpocket/hyperpocket/server/auth/{service_name}.py'
+    if not output_path.exists() or force:
+        with open(output_path, "w") as f:
+            f.write(output_from_parsed_template)
+
+def generate_hyperpocket_auth_dir(service_name, parent_path, force):
+    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'
+    if not output_path.exists() or force:
+        with open(output_path, "w") as f:
+            pass
+
+def generate_auth_context(service_name, capitliazed_service_name, parent_path, force):
+    print(f"Generating auth/context for '{service_name}'.")
+    output_from_parsed_template = get_auth_context_template().render(
+        capitalized_service_name=capitliazed_service_name, 
+        upper_service_name=service_name.upper()
+    )
+    output_path = parent_path / f'hyperpocket/hyperpocket/auth/{service_name}/context.py'
+    if not output_path.exists() or force:
+        with open(output_path, "w") as f:
+            f.write(output_from_parsed_template)
+
+def generate_auth_oauth2_context(service_name, capitliazed_service_name, parent_path, force):
+    print(f"Generating auth/oauth2 context for '{service_name}'.")
+    output_from_parsed_template = get_auth_oauth2_context_template().render(
+        service_name = service_name,
+        capitalized_service_name=capitliazed_service_name, 
+    )
+    output_path = parent_path / f'hyperpocket/hyperpocket/auth/{service_name}/oauth2_context.py'
+    if not output_path.exists() or force:
+        with open(output_path, "w") as f:
+            f.write(output_from_parsed_template)
+
+def generate_auth_oauth2_handler(service_name, capitliazed_service_name, parent_path, force):
+    print(f"Generating auth/oauth2 handler for '{service_name}'.")
+    output_from_parsed_template = get_auth_oauth2_handler_template().render(
+        service_name = service_name,
+        auth_handler_name = service_name.replace('_','-'),
+        capitalized_service_name=capitliazed_service_name,
+        upper_service_name=service_name.upper()
+    )
+    output_path = parent_path / f'hyperpocket/hyperpocket/auth/{service_name}/oauth2_handler.py'
+    if not output_path.exists() or force:
+        with open(output_path, "w") as f:
+            f.write(output_from_parsed_template)
+
+def generate_auth_oauth2_schema(service_name, capitliazed_service_name, parent_path, force):
+    print(f"Generating auth/oauth2 schema for '{service_name}'.")
+    output_from_parsed_template = get_auth_oauth2_schema_template().render(
+        capitalized_service_name=capitliazed_service_name,
+    )
+    output_path = parent_path / f'hyperpocket/hyperpocket/auth/{service_name}/oauth2_schema.py'
+    if not output_path.exists() or force:
+        with open(output_path, "w") as f:
+            f.write(output_from_parsed_template)

hyperpocket/cli/{auth.py → auth_token.py}

@@ -14,7 +14,8 @@ from hyperpocket.cli.codegen.auth import (
 
 @click.command()
 @click.argument("service_name", type=str)
-def create_token_auth_template(service_name):
+@click.option("--force", is_flag=True, default=False)
+def create_token_auth_template(service_name, force):
     ## Validate service_name
     if not service_name.islower() or not service_name.replace("_", "").isalpha():
         raise ValueError(
@@ -31,37 +32,39 @@ def create_token_auth_template(service_name):
     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)
-    generate_auth_token_context(service_name, capitliazed_service_name, parent_path)
-    generate_auth_token_handler(service_name, capitliazed_service_name, parent_path)
-    generate_auth_token_schema(service_name, capitliazed_service_name, parent_path)
+    generate_server_auth(service_name, parent_path, force)
+    generate_hyperpocket_auth_dir(service_name, parent_path, force)
+    generate_auth_context(service_name, capitliazed_service_name, parent_path, force)
+    generate_auth_token_context(service_name, capitliazed_service_name, parent_path, force)
+    generate_auth_token_handler(service_name, capitliazed_service_name, parent_path, force)
+    generate_auth_token_schema(service_name, capitliazed_service_name, parent_path, force)
     ##TODO: Add service to hyperpocket/auth/provider
 
 
-def generate_server_auth(service_name, parent_path):
+def generate_server_auth(service_name, parent_path, force):
     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"
-    with open(output_path, "w") as f:
-        f.write(output_from_parsed_template)
+    if not output_path.exists() or force:
+        with open(output_path, "w") as f:
+            f.write(output_from_parsed_template)
 
 
-def generate_hyperpocket_auth_dir(service_name, parent_path):
+def generate_hyperpocket_auth_dir(service_name, parent_path, force):
     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
+    if not output_path.exists() or force:
+        with open(output_path, "w"):
+            pass
 
 
-def generate_auth_context(service_name, capitliazed_service_name, parent_path):
+def generate_auth_context(service_name, capitliazed_service_name, parent_path, force):
     print(f"Generating auth/context for '{service_name}'.")
     output_from_parsed_template = get_auth_context_template().render(
         caplitalized_service_name=capitliazed_service_name,
@@ -70,11 +73,12 @@ def generate_auth_context(service_name, capitliazed_service_name, parent_path):
     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)
+    if not output_path.exists() or force:
+        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):
+def generate_auth_token_context(service_name, capitliazed_service_name, parent_path, force):
     print(f"Generating auth/token context for '{service_name}'.")
     output_from_parsed_template = get_auth_token_context_template().render(
         service_name=service_name,
@@ -83,11 +87,12 @@ def generate_auth_token_context(service_name, capitliazed_service_name, parent_p
     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)
+    if not output_path.exists() or force:
+        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):
+def generate_auth_token_handler(service_name, capitliazed_service_name, parent_path, force):
     print(f"Generating auth/token handler for '{service_name}'.")
     output_from_parsed_template = get_auth_token_handler_template().render(
         service_name=service_name,
@@ -98,11 +103,12 @@ def generate_auth_token_handler(service_name, capitliazed_service_name, parent_p
     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)
+    if not output_path.exists() or force:
+        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):
+def generate_auth_token_schema(service_name, capitliazed_service_name, parent_path, force):
     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,
@@ -110,5 +116,6 @@ def generate_auth_token_schema(service_name, capitliazed_service_name, parent_pa
     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)
+    if not output_path.exists() or force:
+        with open(output_path, "w") as f:
+            f.write(output_from_parsed_template)

hyperpocket/cli/codegen/auth/__init__.py

@@ -1,13 +1,20 @@
 from .auth_context_template import get_auth_context_template
+from .auth_oauth2_context_template import get_auth_oauth2_context_template
+from .auth_oauth2_handler_template import get_auth_oauth2_handler_template
+from .auth_oauth2_schema_template import get_auth_oauth2_schema_template
 from .auth_token_context_template import get_auth_token_context_template
 from .auth_token_handler_template import get_auth_token_handler_template
 from .auth_token_schema_template import get_auth_token_schema_template
-from .server_auth_template import get_server_auth_token_template
+from .server_auth_template import get_server_auth_token_template, get_server_auth_oauth2_template
 
 __all__ = [
     "get_auth_context_template",
+    "get_auth_oauth2_context_template",
+    "get_auth_oauth2_handler_template",
+    "get_auth_oauth2_schema_template",
     "get_auth_token_context_template",
     "get_auth_token_handler_template",
     "get_auth_token_schema_template",
     "get_server_auth_token_template",
+    "get_server_auth_oauth2_template",
 ]

hyperpocket/cli/codegen/auth/auth_oauth2_context_template.py

@@ -0,0 +1,38 @@
+from jinja2 import Template
+
+def get_auth_oauth2_context_template() -> Template:
+    return Template('''
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.{{ service_name }}.context import {{ capitalized_service_name }}AuthContext
+from hyperpocket.auth.{{ service_name }}.oauth2_schema import {{ capitalized_service_name }}OAuth2Response
+
+
+class {{ capitalized_service_name }}OAuth2AuthContext({{ capitalized_service_name }}AuthContext):
+    refresh_token: Optional[str] = Field(default=None, description="refresh token")
+
+    @classmethod
+    def from_{{ service_name }}_oauth2_response(cls, response: {{ capitalized_service_name }}OAuth2Response):
+        description = f'{{ capitalized_service_name }} OAuth2 Context logged in as a user {response.authed_user.id}'
+        now = datetime.now(tz=timezone.utc)
+
+        access_token = response.access_token
+        refresh_token = response.refresh_token
+        expires_in = response.expires_in
+
+        if expires_in:
+            expires_at = now + timedelta(seconds=response.authed_user.expires_in)
+        else:
+            expires_at = None
+
+        return cls(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            description=description,
+            detail=response,
+        )
+''')

hyperpocket/cli/codegen/auth/auth_oauth2_handler_template.py

@@ -0,0 +1,158 @@
+from jinja2 import Template
+
+def get_auth_oauth2_handler_template() -> Template:
+    return Template('''
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+import httpx
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface
+from hyperpocket.auth.{{ service_name }}.oauth2_context import {{ capitalized_service_name }}OAuth2AuthContext
+from hyperpocket.auth.{{ service_name }}.oauth2_schema import {{ capitalized_service_name }}OAuth2Response, {{ capitalized_service_name }}OAuth2Request
+from hyperpocket.config import config as config
+from hyperpocket.futures import FutureStore
+
+
+class {{ capitalized_service_name }}OAuth2AuthHandler(AuthHandlerInterface):
+    _{{ upper_service_name }}_OAUTH_URL: str = "" # e.g. "https://slack.com/oauth/v2/authorize"
+    _{{ upper_service_name }}_TOKEN_URL: str = "" # e.g. "https://slack.com/api/oauth.v2.access"
+
+    name: str = "{{ auth_handler_name }}-oauth2"
+    description: str = "This handler is used to authenticate users using the {{ capitalized_service_name }} OAuth2 authentication method."
+    scoped: bool = True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.{{ upper_service_name }}
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        """
+        This method returns a set of recommended scopes for the service.
+        If the service has a recommended scope, it should be returned here.
+        Example:
+        return {
+            "channels:history",
+            "channels:read",
+            "chat:write",
+            "groups:history",
+            "groups:read",
+            "im:history",
+            "mpim:history",
+            "reactions:read",
+            "reactions:write",
+        }
+        """
+        return set()
+
+    def prepare(self, auth_req: {{ capitalized_service_name }}OAuth2Request, 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 }}/oauth2/callback",
+        )
+        print(f"redirect_uri: {redirect_uri}")
+        auth_url = self._make_auth_url(req=auth_req, redirect_uri=redirect_uri, state=future_uid)
+
+        FutureStore.create_future(future_uid, data={
+            "redirect_uri": redirect_uri,
+            "thread_id": thread_id,
+            "profile": profile,
+        })
+
+        return f'User needs to authenticate using the following URL: {auth_url}'
+
+    async def authenticate(self, auth_req: {{ capitalized_service_name }}OAuth2Request, future_uid: str, *args, **kwargs) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        auth_code = await future_data.future
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._{{ upper_service_name }}_TOKEN_URL,
+                data={
+                    'client_id': auth_req.client_id,
+                    'client_secret': auth_req.client_secret,
+                    'code': auth_code,
+                    'redirect_uri': future_data.data["redirect_uri"],
+                }
+            )
+        if resp.status_code != 200:
+            raise Exception(f"failed to authenticate. status_code : {resp.status_code}")
+
+        resp_json = resp.json()
+        if resp_json["ok"] is False:
+            raise Exception(f"failed to authenticate. error : {resp_json['error']}")
+
+        resp_typed = {{ capitalized_service_name }}OAuth2Response(**resp_json)
+        return {{ capitalized_service_name }}OAuth2AuthContext.from_{{ service_name }}_oauth2_response(resp_typed)
+
+    async def refresh(self, auth_req: {{ capitalized_service_name }}OAuth2Request, context: AuthContext, *args, **kwargs) -> AuthContext:
+        {{ service_name }}_context: {{ capitalized_service_name }}OAuth2AuthContext = context
+        last_oauth2_resp: {{ capitalized_service_name }}OAuth2Response = {{ service_name }}_context.detail
+        refresh_token = {{ service_name }}_context.refresh_token
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._{{ upper_service_name }}_TOKEN_URL,
+                data={
+                    'client_id': config.auth.{{ service_name }}.client_id,
+                    'client_secret': config.auth.{{ service_name }}.client_secret,
+                    'grant_type': 'refresh_token',
+                    'refresh_token': refresh_token,
+                },
+            )
+
+        if resp.status_code != 200:
+            raise Exception(f"failed to refresh. status_code : {resp.status_code}")
+
+        resp_json = resp.json()
+        if resp_json["ok"] is False:
+            raise Exception(f"failed to refresh. status_code : {resp.status_code}")
+
+        if last_oauth2_resp.authed_user:
+            new_resp = last_oauth2_resp.model_copy(
+                update={
+                    "authed_user": {{ capitalized_service_name }}OAuth2Response.AuthedUser(**{
+                        **last_oauth2_resp.authed_user.model_dump(),
+                        "access_token": resp_json["access_token"],
+                        "refresh_token": resp_json["refresh_token"],
+                        "expires_in": resp_json["expires_in"],
+                    })
+                }
+            )
+        else:
+            new_resp = last_oauth2_resp.model_copy(
+                update={
+                    **last_oauth2_resp.model_dump(),
+                    "access_token": resp_json["access_token"],
+                    "refresh_token": resp_json["refresh_token"],
+                    "expires_in": resp_json["expires_in"],
+                }
+            )
+
+        return {{ capitalized_service_name }}OAuth2AuthContext.from_{{ service_name }}_oauth2_response(new_resp)
+
+    def _make_auth_url(self, req: {{ capitalized_service_name }}OAuth2Request, redirect_uri: str, state: str):
+        params = {
+            "user_scope": ','.join(req.auth_scopes),
+            "client_id": req.client_id,
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._{{ upper_service_name }}_OAUTH_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(self, auth_scopes: Optional[list[str]] = None, **kwargs) -> {{ capitalized_service_name }}OAuth2Request:
+        return {{ capitalized_service_name }}OAuth2Request(
+            auth_scopes=auth_scopes,
+            client_id=config.auth.{{ service_name }}.client_id,
+            client_secret=config.auth.{{ service_name }}.client_secret,
+        )
+''')

hyperpocket/cli/codegen/auth/auth_oauth2_schema_template.py

@@ -0,0 +1,20 @@
+from jinja2 import Template
+
+def get_auth_oauth2_schema_template() -> Template:
+    return Template('''
+from typing import Optional
+
+from pydantic import BaseModel
+
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class {{ capitalized_service_name }}OAuth2Request(AuthenticateRequest):
+    client_id: str
+    client_secret: str
+
+class {{ capitalized_service_name }}OAuth2Response(AuthenticateResponse):
+    access_token: str
+    expires_in: int
+    refresh_token: Optional[str] = Field(default=None)
+''')

hyperpocket/cli/codegen/auth/server_auth_template.py

@@ -2,7 +2,7 @@ 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,5 +15,36 @@ async def {{ service_name }}_token_callback(state: str, token: str):
         FutureStore.resolve_future(state, token)
     except ValueError:
         return HTMLResponse(content="failed")
-    return HTMLResponse(content="success")                    
-""")
+    return HTMLResponse(content="success")
+''')
+    
+def get_server_auth_oauth2_template() -> Template:
+    return Template('''
+from fastapi import APIRouter
+from starlette.responses import HTMLResponse
+from hyperpocket.futures import FutureStore
+
+{{ service_name }}_auth_router = APIRouter(
+    prefix="/{{ service_name }}"
+)
+
+
+@{{ service_name }}_auth_router.get("/oauth2/callback")
+async def {{ service_name }}_oauth2_callback(state: str, code: str):
+    try:
+        FutureStore.resolve_future(state, code)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+
+
+@{{ service_name }}_auth_router.get("/token/callback")
+async def {{ service_name }}_token_callback(state: str, token: str):
+    try:
+        FutureStore.resolve_future(state, token)
+    except ValueError:
+        return HTMLResponse(content="failed")
+
+    return HTMLResponse(content="success")
+''')