hyperpocket 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

hyperpocket/auth/bitwarden/token_handler.py

@@ -0,0 +1,92 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface, AuthenticateRequest
+from hyperpocket.auth.bitwarden.token_context import BitwardenTokenAuthContext
+from hyperpocket.auth.bitwarden.token_schema import (
+    BitwardenTokenResponse,
+    BitwardenTokenRequest,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class BitwardenTokenAuthHandler(AuthHandlerInterface):
+    name: str = "bitwarden-token"
+    description: str = (
+        "This handler is used to authenticate users using the Bitwarden token."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.BITWARDEN
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: BitwardenTokenRequest,
+        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/bitwarden/token/callback",
+        )
+        url = self._make_auth_url(
+            auth_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: {url}"
+
+    async def authenticate(
+        self, auth_req: BitwardenTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = BitwardenTokenResponse(access_token=access_token)
+        context = BitwardenTokenAuthContext.from_bitwarden_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: BitwardenTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Bitwarden token doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: BitwardenTokenRequest, redirect_uri: str, state: str
+    ):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> BitwardenTokenRequest:
+        return BitwardenTokenRequest()

hyperpocket/auth/bitwarden/token_schema.py

@@ -0,0 +1,11 @@
+from typing import List, Optional
+from pydantic import BaseModel
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class BitwardenTokenRequest(AuthenticateRequest):
+    pass
+
+
+class BitwardenTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/brevo/README.md

@@ -0,0 +1,9 @@
+# Brevo Authentication
+
+## Supported Authentication Types
+
+- OAuth2
+
+## Additional Resources
+
+- [Official Documentation](https://developers.brevo.com/)

hyperpocket/auth/brevo/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class BrevoAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "BREVO_TOKEN"
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            self._ACCESS_TOKEN_KEY: self.access_token,
+        }
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/brevo/token_context.py

@@ -0,0 +1,11 @@
+from hyperpocket.auth.brevo.context import BrevoAuthContext
+from hyperpocket.auth.brevo.token_schema import BrevoTokenResponse
+
+
+class BrevoTokenAuthContext(BrevoAuthContext):
+    @classmethod
+    def from_brevo_token_response(cls, response: BrevoTokenResponse):
+        description = f"Brevo Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/brevo/token_handler.py

@@ -0,0 +1,89 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface, AuthenticateRequest
+from hyperpocket.auth.brevo.token_context import BrevoTokenAuthContext
+from hyperpocket.auth.brevo.token_schema import BrevoTokenResponse, BrevoTokenRequest
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class BrevoTokenAuthHandler(AuthHandlerInterface):
+    name: str = "brevo-token"
+    description: str = (
+        "This handler is used to authenticate users using the Brevo token."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.BREVO
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: BrevoTokenRequest,
+        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/brevo/token/callback",
+        )
+        url = self._make_auth_url(
+            auth_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: {url}"
+
+    async def authenticate(
+        self, auth_req: BrevoTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = BrevoTokenResponse(access_token=access_token)
+        context = BrevoTokenAuthContext.from_brevo_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: BrevoTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Brevo token doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: BrevoTokenRequest, redirect_uri: str, state: str
+    ):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> BrevoTokenRequest:
+        return BrevoTokenRequest()

hyperpocket/auth/brevo/token_schema.py

@@ -0,0 +1,11 @@
+from typing import List, Optional
+from pydantic import BaseModel
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class BrevoTokenRequest(AuthenticateRequest):
+    pass
+
+
+class BrevoTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/brex/README.md

@@ -0,0 +1,9 @@
+# Brex Authentication
+
+## Supported Authentication Types
+
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://developer.brex.com/)

hyperpocket/auth/brex/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class BrexAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "BREX_TOKEN"
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            self._ACCESS_TOKEN_KEY: self.access_token,
+        }
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/brex/token_context.py

@@ -0,0 +1,11 @@
+from hyperpocket.auth.brex.context import BrexAuthContext
+from hyperpocket.auth.brex.token_schema import BrexTokenResponse
+
+
+class BrexTokenAuthContext(BrexAuthContext):
+    @classmethod
+    def from_brex_token_response(cls, response: BrexTokenResponse):
+        description = f"Brex Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/brex/token_handler.py

@@ -0,0 +1,87 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface, AuthenticateRequest
+from hyperpocket.auth.brex.token_context import BrexTokenAuthContext
+from hyperpocket.auth.brex.token_schema import BrexTokenResponse, BrexTokenRequest
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class BrexTokenAuthHandler(AuthHandlerInterface):
+    name: str = "brex-token"
+    description: str = (
+        "This handler is used to authenticate users using the Brex token."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.BREX
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: BrexTokenRequest,
+        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/brex/token/callback",
+        )
+        url = self._make_auth_url(
+            auth_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: {url}"
+
+    async def authenticate(
+        self, auth_req: BrexTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = BrexTokenResponse(access_token=access_token)
+        context = BrexTokenAuthContext.from_brex_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: BrexTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Brex token doesn't support refresh")
+
+    def _make_auth_url(self, auth_req: BrexTokenRequest, redirect_uri: str, state: str):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> BrexTokenRequest:
+        return BrexTokenRequest()

hyperpocket/auth/brex/token_schema.py

@@ -0,0 +1,11 @@
+from typing import List, Optional
+from pydantic import BaseModel
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class BrexTokenRequest(AuthenticateRequest):
+    pass
+
+
+class BrexTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/cal/README.md

@@ -0,0 +1,9 @@
+# Cal Authentication
+
+## Supported Authentication Types
+
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://docs.cal.com)

hyperpocket/auth/cal/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class CalAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "CAL_TOKEN"
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            self._ACCESS_TOKEN_KEY: self.access_token,
+        }
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/cal/token_context.py

@@ -0,0 +1,11 @@
+from hyperpocket.auth.cal.context import CalAuthContext
+from hyperpocket.auth.cal.token_schema import CalTokenResponse
+
+
+class CalTokenAuthContext(CalAuthContext):
+    @classmethod
+    def from_cal_token_response(cls, response: CalTokenResponse):
+        description = f"Cal Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/cal/token_handler.py

@@ -0,0 +1,85 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface, AuthenticateRequest
+from hyperpocket.auth.cal.token_context import CalTokenAuthContext
+from hyperpocket.auth.cal.token_schema import CalTokenResponse, CalTokenRequest
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class CalTokenAuthHandler(AuthHandlerInterface):
+    name: str = "cal-token"
+    description: str = "This handler is used to authenticate users using the Cal token."
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.CAL
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: CalTokenRequest,
+        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/cal/token/callback",
+        )
+        url = self._make_auth_url(
+            auth_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: {url}"
+
+    async def authenticate(
+        self, auth_req: CalTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = CalTokenResponse(access_token=access_token)
+        context = CalTokenAuthContext.from_cal_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: CalTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Cal token doesn't support refresh")
+
+    def _make_auth_url(self, auth_req: CalTokenRequest, redirect_uri: str, state: str):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> CalTokenRequest:
+        return CalTokenRequest()

hyperpocket/auth/cal/token_schema.py

@@ -0,0 +1,11 @@
+from typing import List, Optional
+from pydantic import BaseModel
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class CalTokenRequest(AuthenticateRequest):
+    pass
+
+
+class CalTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/calendly/README.md

@@ -0,0 +1,13 @@
+# Calendly Authentication
+
+## Supported Authentication Types
+
+- OAuth2
+
+## How to Create an OAuth2 App
+
+- See here: [link](https://developer.calendly.com/api-docs/3cefb59b832eb-calendly-o-auth-2-0)
+
+## Additional Resources
+
+- [Official Documentation](https://developer.calendly.com)

hyperpocket/auth/canvas/README.md

@@ -0,0 +1,9 @@
+# Canvas Authentication
+
+## Supported Authentication Types
+
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://canvas.instructure.com/doc/api/)

hyperpocket/auth/canvas/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class CanvasAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "CANVAS_TOKEN"
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            self._ACCESS_TOKEN_KEY: self.access_token,
+        }
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/canvas/token_context.py

@@ -0,0 +1,11 @@
+from hyperpocket.auth.canvas.context import CanvasAuthContext
+from hyperpocket.auth.canvas.token_schema import CanvasTokenResponse
+
+
+class CanvasTokenAuthContext(CanvasAuthContext):
+    @classmethod
+    def from_canvas_token_response(cls, response: CanvasTokenResponse):
+        description = f"Canvas Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/canvas/token_handler.py

@@ -0,0 +1,89 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface, AuthenticateRequest
+from hyperpocket.auth.canvas.token_context import CanvasTokenAuthContext
+from hyperpocket.auth.canvas.token_schema import CanvasTokenResponse, CanvasTokenRequest
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class CanvasTokenAuthHandler(AuthHandlerInterface):
+    name: str = "canvas-token"
+    description: str = (
+        "This handler is used to authenticate users using the Canvas token."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/token",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.CANVAS
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: CanvasTokenRequest,
+        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/canvas/token/callback",
+        )
+        url = self._make_auth_url(
+            auth_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: {url}"
+
+    async def authenticate(
+        self, auth_req: CanvasTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = CanvasTokenResponse(access_token=access_token)
+        context = CanvasTokenAuthContext.from_canvas_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: CanvasTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Canvas token doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: CanvasTokenRequest, redirect_uri: str, state: str
+    ):
+        params = {
+            "redirect_uri": redirect_uri,
+            "state": state,
+        }
+        auth_url = f"{self._TOKEN_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> CanvasTokenRequest:
+        return CanvasTokenRequest()