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

hyperpocket/auth/activeloop/README.md

@@ -0,0 +1,8 @@
+# Activeloop Authentication
+
+## Supported Authentication Types
+- Token
+
+## Additional Resources
+
+- [Official Documentation](https://docs.activeloop.ai/setup/authentication)

hyperpocket/auth/activeloop/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.activeloop.context import ActiveloopAuthContext
+from hyperpocket.auth.activeloop.token_schema import ActiveloopTokenResponse
+
+
+class ActiveloopTokenAuthContext(ActiveloopAuthContext):
+    @classmethod
+    def from_activeloop_token_response(cls, response: ActiveloopTokenResponse):
+        description = f"Activeloop Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/activeloop/token_schema.py

@@ -0,0 +1,9 @@
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class ActiveloopTokenRequest(AuthenticateRequest):
+    pass
+
+
+class ActiveloopTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/adobe/README.md

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

hyperpocket/auth/adobe/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.adobe.context import AdobeAuthContext
+from hyperpocket.auth.adobe.token_schema import AdobeTokenResponse
+
+
+class AdobeTokenAuthContext(AdobeAuthContext):
+    @classmethod
+    def from_adobe_token_response(cls, response: AdobeTokenResponse):
+        description = f"Adobe Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/adobe/token_schema.py

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

hyperpocket/auth/affinity/README.md

@@ -0,0 +1,18 @@
+# Affinity Authentication
+
+## Supported Authentication Types
+- Token
+
+## Additional Resources
+
+- [Affinity API Documentation](https://docs.affinity.co)
+
+## How to Create a Token
+
+1. Log in to your Affinity account.
+2. Navigate to the API settings or token management section.
+3. Generate a new API token.
+4. Note down the token for use in your application.
+
+- [Official Documentation](https://docs.affinity.com)
+- [Support](https://support.affinity.com) 

hyperpocket/auth/affinity/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.affinity.context import AffinityAuthContext
+from hyperpocket.auth.affinity.token_schema import AffinityTokenResponse
+
+
+class AffinityTokenAuthContext(AffinityAuthContext):
+    @classmethod
+    def from_affinity_token_response(cls, response: AffinityTokenResponse):
+        description = f"Affinity Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/affinity/token_schema.py

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

hyperpocket/auth/agentql/README.md

@@ -0,0 +1,8 @@
+# AgentQL Authentication
+
+## Supported Authentication Types
+- Token
+
+## Additional Resources
+
+- [AgentQL API Documentation](https://docs.agentql.com) 

hyperpocket/auth/agentql/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.agentql.context import AgentqlAuthContext
+from hyperpocket.auth.agentql.token_schema import AgentqlTokenResponse
+
+
+class AgentqlTokenAuthContext(AgentqlAuthContext):
+    @classmethod
+    def from_agentql_token_response(cls, response: AgentqlTokenResponse):
+        description = f"Agentql Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )

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

hyperpocket/auth/agentql/token_schema.py

@@ -0,0 +1,9 @@
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class AgentqlTokenRequest(AuthenticateRequest):
+    pass
+
+
+class AgentqlTokenResponse(AuthenticateResponse):
+    access_token: str

hyperpocket/auth/ahrefs/README.md

@@ -0,0 +1,8 @@
+# Ahrefs Authentication
+
+## Supported Authentication Types
+- Token
+
+## Additional Resources
+
+- [Ahrefs API Documentation](https://docs.ahrefs.com) 

hyperpocket/auth/ahrefs/context.py

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

@@ -0,0 +1,11 @@
+from hyperpocket.auth.ahrefs.context import AhrefsAuthContext
+from hyperpocket.auth.ahrefs.token_schema import AhrefsTokenResponse
+
+
+class AhrefsTokenAuthContext(AhrefsAuthContext):
+    @classmethod
+    def from_ahrefs_token_response(cls, response: AhrefsTokenResponse):
+        description = f"Ahrefs Token Context logged in"
+        return cls(
+            access_token=response.access_token, description=description, expires_at=None
+        )