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

hyperpocket/auth/linear/oauth2_handler.py

@@ -0,0 +1,155 @@
+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.linear.oauth2_context import LinearOAuth2AuthContext
+from hyperpocket.auth.linear.oauth2_schema import (
+    LinearOAuth2Response,
+    LinearOAuth2Request,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class LinearOAuth2AuthHandler(AuthHandlerInterface):
+    _LINEAR_OAUTH_URL: str = "https://linear.app/oauth/authorize"  # e.g. "https://slack.com/oauth/v2/authorize"
+    _LINEAR_TOKEN_URL: str = "https://api.linear.app/oauth/token"  # e.g. "https://slack.com/api/oauth.v2.access"
+
+    name: str = "linear-oauth2"
+    description: str = "This handler is used to authenticate users using the Linear OAuth2 authentication method."
+    scoped: bool = True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.LINEAR
+
+    @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: LinearOAuth2Request,
+        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/linear/oauth2/callback",
+        )
+        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: LinearOAuth2Request, 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._LINEAR_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"],
+                    "grant_type": "authorization_code",
+                },
+            )
+        resp.raise_for_status()
+        resp_json = resp.json()
+        resp_typed = LinearOAuth2Response(**resp_json)
+        return LinearOAuth2AuthContext.from_linear_oauth2_response(resp_typed)
+
+    async def refresh(
+        self, auth_req: LinearOAuth2Request, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        linear_context: LinearOAuth2AuthContext = context
+        refresh_token = linear_context.refresh_token
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._LINEAR_TOKEN_URL,
+                data={
+                    "client_id": auth_req.client_id,
+                    "client_secret": auth_req.client_secret,
+                    "grant_type": "refresh_token",
+                    "refresh_token": refresh_token,
+                },
+            )
+
+        resp.raise_for_status()
+        resp_json = resp.json()
+
+        new_resp = LinearOAuth2Response(
+            **{
+                "access_token": resp_json["access_token"],
+                "refresh_token": resp_json["refresh_token"],
+                "expires_in": resp_json["expires_in"],
+                "scope": resp_json["scope"],
+            }
+        )
+
+        return LinearOAuth2AuthContext.from_linear_oauth2_response(new_resp)
+
+    def _make_auth_url(self, req: LinearOAuth2Request, redirect_uri: str, state: str):
+        params = {
+            "scope": ",".join(req.auth_scopes),
+            "client_id": req.client_id,
+            "redirect_uri": redirect_uri,
+            "response_type": "code",
+            "state": state,
+            # 'prompt': 'consent', # This can be useful if you want to give users the opportunity to connect multiple workspaces.
+            "actor": "user",  # application, createAsUser
+        }
+        auth_url = f"{self._LINEAR_OAUTH_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> LinearOAuth2Request:
+        return LinearOAuth2Request(
+            auth_scopes=auth_scopes,
+            client_id=config().auth.linear.client_id,
+            client_secret=config().auth.linear.client_secret,
+        )

hyperpocket/auth/linear/oauth2_schema.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class LinearOAuth2Request(AuthenticateRequest):
+    client_id: str
+    client_secret: str
+
+
+class LinearOAuth2Response(AuthenticateResponse):
+    access_token: str
+    expires_in: int
+    token_type: str
+    scope: Optional[str] = Field(default=None)

hyperpocket/auth/linkedin/README.md

@@ -0,0 +1,16 @@
+# Linkedin Authentication
+
+This document provides instructions on how to set up OAuth2 authentication for Linkedin using Hyperpocket.
+
+## Supported Authentication Types
+
+- OAuth2
+
+## How to Create an OAuth2 App
+
+- See here: [link](https://learn.microsoft.com/en-us/linkedin/shared/authentication/authentication)
+
+## Additional Resources
+
+- [Official Documentation](https://docs.microsoft.com/en-us/linkedin/shared/authentication/authentication)
+- [Support](https://www.linkedin.com/help/linkedin) 

hyperpocket/auth/linkedin/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class LinkedinAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "LINKEDIN_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/linkedin/oauth2_context.py

@@ -0,0 +1,33 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.linkedin.context import LinkedinAuthContext
+from hyperpocket.auth.linkedin.oauth2_schema import LinkedinOAuth2Response
+
+
+class LinkedinOAuth2AuthContext(LinkedinAuthContext):
+    refresh_token: Optional[str] = Field(default=None, description="refresh token")
+
+    @classmethod
+    def from_linkedin_oauth2_response(cls, response: LinkedinOAuth2Response):
+        description = f"Linkedin OAuth2 Context logged in"
+        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.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/auth/linkedin/oauth2_handler.py

@@ -0,0 +1,154 @@
+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.linkedin.oauth2_context import LinkedinOAuth2AuthContext
+from hyperpocket.auth.linkedin.oauth2_schema import (
+    LinkedinOAuth2Response,
+    LinkedinOAuth2Request,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class LinkedinOAuth2AuthHandler(AuthHandlerInterface):
+    _LINKEDIN_OAUTH_URL: str = "https://www.linkedin.com/oauth/v2/authorization"  # e.g. "https://slack.com/oauth/v2/authorize"
+    _LINKEDIN_TOKEN_URL: str = "https://www.linkedin.com/oauth/v2/accessToken"  # e.g. "https://slack.com/api/oauth.v2.access"
+
+    name: str = "linkedin-oauth2"
+    description: str = "This handler is used to authenticate users using the Linkedin OAuth2 authentication method."
+    scoped: bool = True
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.LINKEDIN
+
+    @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: LinkedinOAuth2Request,
+        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/linkedin/oauth2/callback",
+        )
+        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: LinkedinOAuth2Request, 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._LINKEDIN_TOKEN_URL,
+                data={
+                    "client_id": auth_req.client_id,
+                    "client_secret": auth_req.client_secret,
+                    "code": auth_code,
+                    "grant_type": "authorization_code",
+                    "redirect_uri": future_data.data["redirect_uri"],
+                },
+            )
+        resp.raise_for_status()
+        resp_json = resp.json()
+        resp_typed = LinkedinOAuth2Response(**resp_json)
+        return LinkedinOAuth2AuthContext.from_linkedin_oauth2_response(resp_typed)
+
+    async def refresh(
+        self, auth_req: LinkedinOAuth2Request, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        linkedin_context: LinkedinOAuth2AuthContext = context
+        refresh_token = linkedin_context.refresh_token
+
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                url=self._LINKEDIN_TOKEN_URL,
+                data={
+                    "client_id": auth_req.client_id,
+                    "client_secret": auth_req.client_secret,
+                    "grant_type": "refresh_token",
+                    "refresh_token": refresh_token,
+                },
+            )
+
+        resp.raise_for_status()
+        resp_json = resp.json()
+
+        new_resp = LinkedinOAuth2Response(
+            **{
+                "access_token": resp_json["access_token"],
+                "refresh_token": resp_json["refresh_token"],
+                "refresh_token_expires_in": resp_json["refresh_token_expires_in"],
+                "expires_in": resp_json["expires_in"],
+                "scope": resp_json["scope"],
+            }
+        )
+
+        return LinkedinOAuth2AuthContext.from_linkedin_oauth2_response(new_resp)
+
+    def _make_auth_url(self, req: LinkedinOAuth2Request, redirect_uri: str, state: str):
+        params = {
+            "scope": " ".join(req.auth_scopes),
+            "client_id": req.client_id,
+            "redirect_uri": redirect_uri,
+            "response_type": "code",
+            "state": state,
+        }
+        auth_url = f"{self._LINKEDIN_OAUTH_URL}?{urlencode(params)}"
+        return auth_url
+
+    def make_request(
+        self, auth_scopes: Optional[list[str]] = None, **kwargs
+    ) -> LinkedinOAuth2Request:
+        return LinkedinOAuth2Request(
+            auth_scopes=auth_scopes,
+            client_id=config().auth.linkedin.client_id,
+            client_secret=config().auth.linkedin.client_secret,
+        )

hyperpocket/auth/linkedin/oauth2_schema.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class LinkedinOAuth2Request(AuthenticateRequest):
+    client_id: str
+    client_secret: str
+
+
+class LinkedinOAuth2Response(AuthenticateResponse):
+    access_token: str
+    expires_in: int
+    refresh_token: Optional[str] = Field(default=None)
+    refresh_token_expires_in: Optional[int] = Field(default=None)
+    scope: Optional[str] = Field(default=None)

hyperpocket/auth/listennotes/README.md

@@ -0,0 +1,12 @@
+# Listennotes Authentication
+
+This document provides instructions on how to set up token-based authentication for Listennotes using Hyperpocket.
+
+## Supported Authentication Types
+
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://www.listennotes.com/api/docs/)
+- [Support](https://www.listennotes.com/contact/)

hyperpocket/auth/listennotes/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class ListennotesAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "LISTENNOTES_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/listennotes/token_context.py

@@ -0,0 +1,11 @@
+from hyperpocket.auth.listennotes.context import ListennotesAuthContext
+from hyperpocket.auth.listennotes.token_schema import ListennotesTokenResponse
+
+
+class ListennotesTokenAuthContext(ListennotesAuthContext):
+    @classmethod
+    def from_listennotes_token_response(cls, response: ListennotesTokenResponse):
+        description = f"Listennotes Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

hyperpocket/auth/listennotes/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.listennotes.token_context import ListennotesTokenAuthContext
+from hyperpocket.auth.listennotes.token_schema import (
+    ListennotesTokenResponse,
+    ListennotesTokenRequest,
+)
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class ListennotesTokenAuthHandler(AuthHandlerInterface):
+    name: str = "listennotes-token"
+    description: str = (
+        "This handler is used to authenticate users using the Listennotes 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.LISTENNOTES
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: ListennotesTokenRequest,
+        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/listennotes/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: ListennotesTokenRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        access_token = await future_data.future
+
+        response = ListennotesTokenResponse(access_token=access_token)
+        context = ListennotesTokenAuthContext.from_listennotes_token_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: ListennotesTokenRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Listennotes token doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: ListennotesTokenRequest, 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
+    ) -> ListennotesTokenRequest:
+        return ListennotesTokenRequest()

hyperpocket/auth/listennotes/token_schema.py

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

hyperpocket/auth/mailchimp/README.md

@@ -0,0 +1,16 @@
+# Mailchimp Authentication
+
+This document provides instructions on how to set up OAuth2 authentication for Mailchimp using Hyperpocket.
+
+## Supported Authentication Types
+
+- OAuth2
+
+## How to Create an OAuth2 App
+
+- See here: [link](https://mailchimp.com/developer/marketing/guides/access-user-data-oauth-2/)
+
+## Additional Resources
+
+- [Official Documentation](https://mailchimp.com/developer/marketing/guides/quick-start/)
+- [Support](https://mailchimp.com/help/) 

hyperpocket/auth/mailchimp/context.py

@@ -0,0 +1,15 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class MailchimpAuthContext(AuthContext):
+    _ACCESS_TOKEN_KEY: str = "MAILCHIMP_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/mailchimp/oauth2_context.py

@@ -0,0 +1,33 @@
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from pydantic import Field
+
+from hyperpocket.auth.mailchimp.context import MailchimpAuthContext
+from hyperpocket.auth.mailchimp.oauth2_schema import MailchimpOAuth2Response
+
+
+class MailchimpOAuth2AuthContext(MailchimpAuthContext):
+    refresh_token: Optional[str] = Field(default=None, description="refresh token")
+
+    @classmethod
+    def from_mailchimp_oauth2_response(cls, response: MailchimpOAuth2Response):
+        description = f"Mailchimp OAuth2 Context logged in"
+        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.expires_in)
+        else:
+            expires_at = None
+
+        return cls(
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            description=description,
+            detail=response,
+        )