hyperpocket 0.4.4__py3-none-any.whl → 0.5.0__py3-none-any.whl

hyperpocket/auth/kraken/README.md

@@ -0,0 +1,8 @@
+# Valyu Authentication
+
+## Supported Authentication Types
+- Token
+
+## Additional Resources
+
+- [Valyu API Documentation](https://www.valyu.network/) 

hyperpocket/auth/kraken/context.py

@@ -0,0 +1,14 @@
+from hyperpocket.auth.context import AuthContext
+
+
+class KrakenAuthContext(AuthContext):
+    def to_dict(self) -> dict[str, str]:
+        return {
+            'KRAKEN_API_KEY': self.detail["KRAKEN_API_KEY"],
+            'KRAKEN_API_SECRET': self.detail["KRAKEN_API_SECRET"],
+        }
+
+    def to_profiled_dict(self, profile: str) -> dict[str, str]:
+        return {
+            f"{profile.upper()}_{self._ACCESS_TOKEN_KEY}": self.access_token,
+        }

hyperpocket/auth/kraken/keypair_context.py

@@ -0,0 +1,17 @@
+from hyperpocket.auth.kraken.context import KrakenAuthContext
+from hyperpocket.auth.kraken.keypair_schema import KrakenKeypairResponse
+
+
+class KrakenKeypairAuthContext(KrakenAuthContext):
+    @classmethod
+    def from_kraken_keypair_response(cls, response: KrakenKeypairResponse):
+        description = f"Kraken Keypair Context logged in"
+        return cls(
+            access_token="",
+            detail={
+                "KRAKEN_API_KEY": response.kraken_api_key,
+                "KRAKEN_API_SECRET": response.kraken_api_secret,
+            },
+            description=description,
+            expires_at=None,
+        )

hyperpocket/auth/kraken/keypair_handler.py

@@ -0,0 +1,97 @@
+from typing import Optional
+from urllib.parse import urljoin, urlencode
+
+from hyperpocket.auth import AuthProvider
+from hyperpocket.auth.ahrefs.token_schema import AhrefsTokenRequest
+from hyperpocket.auth.context import AuthContext
+from hyperpocket.auth.handler import AuthHandlerInterface
+from hyperpocket.auth.kraken.keypair_context import KrakenKeypairAuthContext
+from hyperpocket.auth.kraken.keypair_schema import KrakenKeypairRequest, KrakenKeypairResponse
+from hyperpocket.config import config
+from hyperpocket.futures import FutureStore
+
+
+class KrakeyKeypairAuthHandler(AuthHandlerInterface):
+    name: str = "kraken-keypair"
+    description: str = (
+        "This handler is used to authenticate users using the Kraken keypair."
+    )
+    scoped: bool = False
+
+    _TOKEN_URL: str = urljoin(
+        config().public_base_url + "/",
+        f"{config().callback_url_rewrite_prefix}/auth/kraken/keypair",
+    )
+
+    @staticmethod
+    def provider() -> AuthProvider:
+        return AuthProvider.KRAKEN
+
+    @staticmethod
+    def provider_default() -> bool:
+        return True
+
+    @staticmethod
+    def recommended_scopes() -> set[str]:
+        return set()
+
+    def prepare(
+        self,
+        auth_req: AhrefsTokenRequest,
+        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/kraken/keypair/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: KrakenKeypairRequest, future_uid: str, *args, **kwargs
+    ) -> AuthContext:
+        future_data = FutureStore.get_future(future_uid)
+        kraken_api_keypair = await future_data.future
+
+        response = KrakenKeypairResponse(
+            kraken_api_key=kraken_api_keypair["kraken_api_key"],
+            kraken_api_secret=kraken_api_keypair["kraken_api_secret"],
+        )
+        context = KrakenKeypairAuthContext.from_kraken_keypair_response(response)
+
+        return context
+
+    async def refresh(
+        self, auth_req: KrakenKeypairRequest, context: AuthContext, *args, **kwargs
+    ) -> AuthContext:
+        raise Exception("Kraken keypair doesn't support refresh")
+
+    def _make_auth_url(
+        self, auth_req: KrakenKeypairRequest, 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
+    ) -> KrakenKeypairRequest:
+        return KrakenKeypairRequest()

hyperpocket/auth/kraken/keypair_schema.py

@@ -0,0 +1,10 @@
+from hyperpocket.auth.schema import AuthenticateRequest, AuthenticateResponse
+
+
+class KrakenKeypairRequest(AuthenticateRequest):
+    pass
+
+
+class KrakenKeypairResponse(AuthenticateResponse):
+    kraken_api_key: str
+    kraken_api_secret: str

hyperpocket/auth/provider.py

@@ -74,6 +74,7 @@ class AuthProvider(Enum):
     SEMANTIC_SCHOLAR = "semantic_scholar"
     WEAVIATE = "weaviate"
     VALYU = "valyu"
+    KRAKEN = "kraken"
 
     @classmethod
     def get_auth_provider(cls, auth_provider_name: str) -> "AuthProvider":

hyperpocket/auth/valyu/token_handler.py

@@ -2,7 +2,6 @@ from typing import Optional
 from urllib.parse import urljoin, urlencode
 
 from hyperpocket.auth import AuthProvider
-from hyperpocket.auth.ahrefs.token_schema import AhrefsTokenRequest
 from hyperpocket.auth.context import AuthContext
 from hyperpocket.auth.handler import AuthHandlerInterface
 from hyperpocket.auth.valyu.token_context import ValyuTokenAuthContext
@@ -37,7 +36,7 @@ class ValyuTokenAuthHandler(AuthHandlerInterface):
 
     def prepare(
         self,
-        auth_req: AhrefsTokenRequest,
+        auth_req: ValyuTokenRequest,
         thread_id: str,
         profile: str,
         future_uid: str,

hyperpocket/builtin.py

@@ -12,7 +12,7 @@ def get_builtin_tools(pocket_auth: PocketAuth) -> List[Tool]:
     Builtin Tool can access to Pocket Core.
     """
 
-    def __get_current_thread_session_state(thread_id: str = "default") -> str:
+    async def __get_current_thread_session_state(thread_id: str = "default") -> str:
         """
         This tool retrieves the current session state list for the specified thread.
 
@@ -31,7 +31,7 @@ def get_builtin_tools(pocket_auth: PocketAuth) -> List[Tool]:
 
         This tool ensures transparency about the current session but must respect user-driven intent and should never be called automatically or without a specific user request.
         """
-        session_list = pocket_auth.list_session_state(thread_id)
+        session_list = await pocket_auth.list_session_state(thread_id)
         return str(session_list)
 
     def __delete_session(
@@ -58,7 +58,7 @@ def get_builtin_tools(pocket_auth: PocketAuth) -> List[Tool]:
         return str(is_deleted)
 
     builtin_tools = [
-        from_func(func=__get_current_thread_session_state),
+        from_func(func=__get_current_thread_session_state, afunc=__get_current_thread_session_state),
         from_func(func=__delete_session),
     ]
 

hyperpocket/cli/__main__.py

@@ -2,7 +2,6 @@ import click
 
 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
@@ -28,7 +27,6 @@ devtool.add_command(build_tool)
 devtool.add_command(export_tool)
 
 cli.add_command(pull)
-cli.add_command(sync)
 cli.add_command(eject)
 
 cli()

hyperpocket/config/logger.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import pathlib
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
 
@@ -27,9 +28,7 @@ class ColorFormatter(logging.Formatter):
 
 
 def get_logger():
-    # init log file
-    package_path = Path(os.path.dirname(hyperpocket.__file__))
-    log_dir = package_path / ".log"
+    log_dir = pathlib.Path(os.getcwd()) / ".log"
     os.makedirs(log_dir, exist_ok=True)
     log_file = log_dir / "pocket.log"
     if not log_file.exists():

hyperpocket/futures/futurestore.py

@@ -25,7 +25,6 @@ class FutureStore(object):
                 f"the future already exists. the existing future is returned. uid: {uid}"
             )
             return future
-
         loop = asyncio.get_running_loop()
         future = loop.create_future()
         future_data = FutureData(future=future, data=data)
@@ -42,7 +41,13 @@ class FutureStore(object):
         if not future_data:
             raise ValueError(f"Future not found for uid={uid}")
         if not future_data.future.done():
-            future_data.future.set_result(value)
+            # if the future loop is running, it should be executed in same event loop
+            loop = future_data.future.get_loop()
+            if loop.is_running():
+                loop.call_soon_threadsafe(future_data.future.set_result, value)
+            # if the future loop is not running, it can be executed from anywhere.
+            else:
+                future_data.future.set_result(value)
 
     def delete_future(self, uid: str):
         self.futures.pop(uid, None)

hyperpocket/pocket_auth.py

@@ -78,7 +78,7 @@ class PocketAuth(object):
         handler = self.find_handler_instance(auth_handler_name, auth_provider)
         return handler.make_request(auth_scopes, **kwargs)
 
-    def check(
+    async def check(
         self,
         auth_req: AuthenticateRequest,
         auth_handler_name: Optional[str] = None,
@@ -112,12 +112,12 @@ class PocketAuth(object):
         """
         handler = self.find_handler_instance(auth_handler_name, auth_provider)
         session = self.session_storage.get(handler.provider(), thread_id, profile)
-        auth_state = self.get_session_state(session=session, auth_req=auth_req)
+        auth_state = await self.get_session_state(session=session, auth_req=auth_req)
 
         return auth_state
 
     @staticmethod
-    def get_session_state(
+    async def get_session_state(
         session: Optional[BaseSessionValue], auth_req: Optional[AuthenticateRequest]
     ) -> AuthState:
         if not session:
@@ -125,6 +125,8 @@ class PocketAuth(object):
 
         if session.auth_resolve_uid:
             future_data = FutureStore.get_future(session.auth_resolve_uid)
+            # it yields before checking future's state, because the future is being resolved on another thread's event loop.
+            await asyncio.sleep(0)
             if future_data is not None and future_data.future.done():
                 return AuthState.RESOLVED
 
@@ -140,7 +142,7 @@ class PocketAuth(object):
 
         return AuthState.SKIP_AUTH
 
-    def prepare(
+    async def prepare(
         self,
         auth_req: AuthenticateRequest,
         auth_handler_name: Optional[str] = None,
@@ -166,7 +168,7 @@ class PocketAuth(object):
         Returns:
             Optional[str]: authentication URL
         """
-        auth_state = self.check(
+        auth_state = await self.check(
             auth_req=auth_req,
             auth_handler_name=auth_handler_name,
             auth_provider=auth_provider,
@@ -263,7 +265,7 @@ class PocketAuth(object):
         Returns:
             AuthContext: authentication context
         """
-        auth_state = self.check(
+        auth_state = await self.check(
             auth_req=auth_req,
             auth_handler_name=auth_handler_name,
             auth_provider=auth_provider,
@@ -353,7 +355,7 @@ class PocketAuth(object):
 
         return session.auth_context
 
-    def list_session_state(
+    async def list_session_state(
         self, thread_id: str, auth_provider: Optional[AuthProvider] = None
     ):
         session_list = self.session_storage.get_by_thread_id(
@@ -361,7 +363,7 @@ class PocketAuth(object):
         )
         session_state_list = []
         for session in session_list:
-            state = self.get_session_state(session=session, auth_req=None)
+            state = await self.get_session_state(session=session, auth_req=None)
 
             session_state_list.append(
                 {