hyperpocket 0.1.10__py3-none-any.whl → 0.2.0__py3-none-any.whl

hyperpocket/server/auth/token.py

@@ -1,5 +1,5 @@
 from http import HTTPStatus
-from urllib.parse import urlencode, urlunparse, urlparse, parse_qs
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 
 from fastapi import APIRouter, Form
 from starlette.responses import HTMLResponse, RedirectResponse
@@ -29,8 +29,12 @@ async def token_form(redirect_uri: str, state: str = ""):
 
 
 @token_router.post("/submit", response_class=RedirectResponse)
-async def submit_token(user_token: str = Form(...), redirect_uri: str = Form(...), state: str = Form(...)):
-    new_callback_url = add_query_params(redirect_uri, {"token": user_token, "state": state})
+async def submit_token(
+    user_token: str = Form(...), redirect_uri: str = Form(...), state: str = Form(...)
+):
+    new_callback_url = add_query_params(
+        redirect_uri, {"token": user_token, "state": state}
+    )
     return RedirectResponse(url=new_callback_url, status_code=HTTPStatus.SEE_OTHER)
 
 
@@ -40,12 +44,14 @@ def add_query_params(url: str, params: dict):
     query_params.update(params)
     new_query = urlencode(query_params, doseq=True)
 
-    new_url = urlunparse((
-        url_parts.scheme,
-        url_parts.netloc,
-        url_parts.path,
-        url_parts.params,
-        new_query,
-        url_parts.fragment
-    ))
+    new_url = urlunparse(
+        (
+            url_parts.scheme,
+            url_parts.netloc,
+            url_parts.path,
+            url_parts.params,
+            new_query,
+            url_parts.fragment,
+        )
+    )
     return new_url

hyperpocket/server/proxy.py

@@ -9,22 +9,27 @@ async def proxy(request: Request, path: str):
     async with httpx.AsyncClient() as client:
         resp = await client.request(
             method=request.method,
-            url=f"{config.internal_base_url}/{path}",
+            url=f"{config().internal_base_url}/{path}",
             headers=request.headers,
             content=await request.body(),
             params=request.query_params,
             timeout=300,
         )
-        return HTMLResponse(content=resp.text, headers=resp.headers, status_code=resp.status_code)
+        return HTMLResponse(
+            content=resp.text, headers=resp.headers, status_code=resp.status_code
+        )
 
 
 def add_callback_proxy(app: FastAPI):
-    app.add_api_route(f"/{config.callback_url_rewrite_prefix}/{{path:path}}", proxy,
-                      methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"])
+    app.add_api_route(
+        f"/{config().callback_url_rewrite_prefix}/{{path:path}}",
+        proxy,
+        methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+    )
 
 
 https_proxy_app = None
-if config.enable_local_callback_proxy:
+if config().enable_local_callback_proxy:
     https_proxy_app = FastAPI()
     add_callback_proxy(https_proxy_app)
 
@@ -44,20 +49,31 @@ def _generate_ssl_certificates(ssl_keypath, ssl_certpath):
         "/emailAddress=local@example.com"
     )
     command = [
-        "openssl", "req", "-x509",
-        "-newkey", "rsa:4096",
-        "-keyout", ssl_keypath,
-        "-out", ssl_certpath,
-        "-days", "1",
+        "openssl",
+        "req",
+        "-x509",
+        "-newkey",
+        "rsa:4096",
+        "-keyout",
+        ssl_keypath,
+        "-out",
+        ssl_certpath,
+        "-days",
+        "1",
         "-nodes",
-        '-subj', subj,
+        "-subj",
+        subj,
         "-sha256",
     ]
 
     try:
         # 명령 실행
-        subprocess.run(command, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        pocket_logger.info("SSL Certificates generated: callback_server.key, callback_server.crt")
+        subprocess.run(
+            command, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+        )
+        pocket_logger.info(
+            "SSL Certificates generated: callback_server.key, callback_server.crt"
+        )
     except subprocess.CalledProcessError as e:
         pocket_logger.warning(f"An error occurred while generating certificates: {e}")
         raise e

hyperpocket/server/server.py

@@ -30,9 +30,11 @@ class PocketServer(object):
     future_store: dict[str, asyncio.Future]
     torn_down: bool = False
 
-    def __init__(self,
-                 internal_server_port: int = config.internal_server_port,
-                 proxy_port: int = config.public_server_port):
+    def __init__(
+        self,
+        internal_server_port: int = config().internal_server_port,
+        proxy_port: int = config().public_server_port,
+    ):
         self.internal_server_port = internal_server_port
         self.proxy_port = proxy_port
         self.future_store = dict()
@@ -49,7 +51,9 @@ class PocketServer(object):
         try:
             await asyncio.gather(
                 self.main_server.serve(),
-                self.proxy_server.serve() if self.proxy_server is not None else asyncio.sleep(0),
+                self.proxy_server.serve()
+                if self.proxy_server is not None
+                else asyncio.sleep(0),
                 self.poll_in_child(),
             )
         except Exception as e:
@@ -75,7 +79,9 @@ class PocketServer(object):
                 result = self.pocket_core.prepare_auth(*a, **kw)
                 error = None
             except Exception as e:
-                pocket_logger.error(f"failed to prepare in pocket subprocess. error: {e}")
+                pocket_logger.error(
+                    f"failed to prepare in pocket subprocess. error: {e}"
+                )
                 result = None
                 error = e
 
@@ -86,7 +92,9 @@ class PocketServer(object):
                 result = await self.pocket_core.authenticate(*a, **kw)
                 error = None
             except Exception as e:
-                pocket_logger.error(f"failed to authenticate in pocket subprocess. error: {e}")
+                pocket_logger.error(
+                    f"failed to authenticate in pocket subprocess. error: {e}"
+                )
                 result = None
                 error = e
 
@@ -97,7 +105,9 @@ class PocketServer(object):
                 result = await self.pocket_core.tool_call(*a, **kw)
                 error = None
             except Exception as e:
-                pocket_logger.error(f"failed to tool_call in pocket subprocess. error: {e}")
+                pocket_logger.error(
+                    f"failed to tool_call in pocket subprocess. error: {e}"
+                )
                 result = None
                 error = e
 
@@ -119,10 +129,7 @@ class PocketServer(object):
             else:
                 await asyncio.sleep(0)
 
-    def send_in_parent(self,
-                       op: PocketServerOperations,
-                       args: tuple,
-                       kwargs: dict):
+    def send_in_parent(self, op: PocketServerOperations, args: tuple, kwargs: dict):
         conn, _ = self.pipe
         uid = str(uuid.uuid4())
         message = (op.value, uid, args, kwargs)
@@ -145,10 +152,9 @@ class PocketServer(object):
             else:
                 await asyncio.sleep(0)
 
-    async def call_in_subprocess(self,
-                                 op: PocketServerOperations,
-                                 args: tuple,
-                                 kwargs: dict):
+    async def call_in_subprocess(
+        self, op: PocketServerOperations, args: tuple, kwargs: dict
+    ):
         uid = self.send_in_parent(op, args, kwargs)
         loop = asyncio.get_running_loop()
         loop.create_task(self.poll_in_parent())
@@ -157,21 +163,52 @@ class PocketServer(object):
     def run(self, pocket_core: PocketCore):
         self._set_mp_start_method()
 
+        error_queue = mp.Queue()
         self.pipe = mp.Pipe()
-        self.process = mp.Process(target=self._run, args=(pocket_core,))
-        self.process.start()
+        self.process = mp.Process(
+            target=self._run, args=(pocket_core, )
+        )
+        self.process.start()  # process start
+
+        if not error_queue.empty():
+            error_message = error_queue.get()
+            raise error_message
+    
+    def _report_initialized(self, error: Optional[Exception] = None):
+        _, conn = self.pipe
+        conn.send(('server-initialization', error,))
+    
+    def wait_initialized(self):
+        conn, _ = self.pipe
+        while True:
+            if conn.poll():
+                _, error = conn.recv()
+                if error:
+                    raise error
+                return
 
     def _run(self, pocket_core):
-        self.pocket_core = pocket_core
-        self.main_server = self._create_main_server()
-        self.proxy_server = self._create_https_proxy_server()
-        loop = asyncio.new_event_loop()
-        loop.run_until_complete(self._run_async())
-        loop.close()
+        try:
+            # init process
+            self.pocket_core = pocket_core
+            self.main_server = self._create_main_server()
+            self.proxy_server = self._create_https_proxy_server()
+            self._report_initialized()
+
+            loop = asyncio.new_event_loop()
+            loop.run_until_complete(self._run_async())
+            loop.close()
+        except Exception as error:
+            self._report_initialized(error)
 
     def _create_main_server(self) -> Server:
         app = FastAPI()
-        _config = Config(app, host="0.0.0.0", port=self.internal_server_port)
+        _config = Config(
+            app,
+            host="0.0.0.0",
+            port=self.internal_server_port,
+            log_level=config().log_level,
+        )
         app.include_router(tool_router)
         app.include_router(auth_router)
         app.add_api_route("/health", lambda: {"status": "ok"}, methods=["GET"])
@@ -180,20 +217,25 @@ class PocketServer(object):
         return app
 
     def _create_https_proxy_server(self) -> Optional[Server]:
-        if not config.enable_local_callback_proxy:
+        if not config().enable_local_callback_proxy:
             return None
-        from hyperpocket.server.proxy import _generate_ssl_certificates
-        from hyperpocket.server.proxy import https_proxy_app
-
         from hyperpocket.config.settings import POCKET_ROOT
+        from hyperpocket.server.proxy import _generate_ssl_certificates, https_proxy_app
+
         ssl_keypath = POCKET_ROOT / "callback_server.key"
         ssl_certpath = POCKET_ROOT / "callback_server.crt"
 
         if not ssl_keypath.exists() or not ssl_certpath.exists():
             _generate_ssl_certificates(ssl_keypath, ssl_certpath)
 
-        _config = Config(https_proxy_app, host="0.0.0.0", port=self.proxy_port, ssl_keyfile=ssl_keypath,
-                         ssl_certfile=ssl_certpath)
+        _config = Config(
+            https_proxy_app,
+            host="0.0.0.0",
+            port=self.proxy_port,
+            ssl_keyfile=ssl_keypath,
+            ssl_certfile=ssl_certpath,
+            log_level=config().log_level,
+        )
         proxy_server = Server(_config)
         return proxy_server
 
@@ -211,4 +253,6 @@ class PocketServer(object):
             mp.set_start_method("fork", force=True)
             pocket_logger.debug("Process start method set to 'fork' for Linux.")
         else:
-            pocket_logger.debug(f"Unrecognized OS: {os_name}. Default start method will be used.")
+            pocket_logger.debug(
+                f"Unrecognized OS: {os_name}. Default start method will be used."
+            )

hyperpocket/server/tool/dto/script.py

@@ -1,28 +1,33 @@
 from typing import Optional
+
 from pydantic import BaseModel, Field
 
 from hyperpocket.tool.wasm.script import ScriptFileNode
 
 
 class Script(BaseModel):
-    id: str = Field(alias='id')
-    tool_id: str = Field(alias='tool_id')
+    id: str = Field(alias="id")
+    tool_id: str = Field(alias="tool_id")
 
 
 class ScriptResult(BaseModel):
-    stdout: Optional[str] = Field(alias='stdout', default=None)
-    stderr: Optional[str] = Field(alias='stderr', default=None)
-    error: Optional[str] = Field(alias='error', default=None)
+    stdout: Optional[str] = Field(alias="stdout", default=None)
+    stderr: Optional[str] = Field(alias="stderr", default=None)
+    error: Optional[str] = Field(alias="error", default=None)
+
 
 class ScriptFileTree(BaseModel):
-    tree: dict[str, ScriptFileNode] = Field(alias='tree')
+    tree: dict[str, ScriptFileNode] = Field(alias="tree")
+
 
 class ScriptEntrypoint(BaseModel):
-    package_name: Optional[str] = Field(alias='package_name')
-    entrypoint: str = Field(alias='entrypoint')
+    package_name: Optional[str] = Field(alias="package_name")
+    entrypoint: str = Field(alias="entrypoint")
+
 
 class ScriptEncodedFile(BaseModel):
-    encoded_file: str = Field(alias='encoded_file')
+    encoded_file: str = Field(alias="encoded_file")
+
 
 class ScriptFileRequest(BaseModel):
-    path: str = Field(alias='path')
+    path: str = Field(alias="path")

hyperpocket/server/tool/wasm.py

@@ -1,13 +1,11 @@
 from fastapi import APIRouter
-from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.responses import FileResponse, HTMLResponse
 
 from hyperpocket.futures import FutureStore
 from hyperpocket.server.tool.dto import script as scriptdto
 from hyperpocket.tool.wasm.script import ScriptStore
 
-wasm_tool_router = APIRouter(
-    prefix="/wasm"
-)
+wasm_tool_router = APIRouter(prefix="/wasm")
 
 
 @wasm_tool_router.get("/scripts/{script_id}/browse", response_class=HTMLResponse)
@@ -17,19 +15,21 @@ async def browse_script_page(script_id: str):
 
 
 @wasm_tool_router.post("/scripts/{script_id}/done")
-async def done_script_page(script_id: str, req: scriptdto.ScriptResult) -> scriptdto.ScriptResult:
-    FutureStore.resolve_future(script_id, {
-        'stdout': req.stdout,
-        'stderr': req.stderr,
-        'error': req.error
-    })
+async def done_script_page(
+    script_id: str, req: scriptdto.ScriptResult
+) -> scriptdto.ScriptResult:
+    FutureStore.resolve_future(
+        script_id, {"stdout": req.stdout, "stderr": req.stderr, "error": req.error}
+    )
     return req
 
+
 @wasm_tool_router.get("/scripts/{script_id}/file_tree")
 async def get_file_tree(script_id: str) -> scriptdto.ScriptFileTree:
     script = ScriptStore.get_script(script_id)
     return scriptdto.ScriptFileTree(tree=script.load_file_tree())
 
+
 @wasm_tool_router.get("/scripts/{script_id}/entrypoint")
 async def get_entrypoint(script_id: str) -> scriptdto.ScriptEntrypoint:
     script = ScriptStore.get_script(script_id)
@@ -37,7 +37,10 @@ async def get_entrypoint(script_id: str) -> scriptdto.ScriptEntrypoint:
     entrypoint = f"/tools/wasm/scripts/{script_id}/file/{script.entrypoint}"
     return scriptdto.ScriptEntrypoint(package_name=package_name, entrypoint=entrypoint)
 
-@wasm_tool_router.get("/scripts/{script_id}/file/{file_name}", response_class=FileResponse)
+
+@wasm_tool_router.get(
+    "/scripts/{script_id}/file/{file_name}", response_class=FileResponse
+)
 async def get_dist_file(script_id: str, file_name: str):
     script = ScriptStore.get_script(script_id)
     return FileResponse(script.dist_file_path(file_name))

hyperpocket/session/__init__.py

@@ -1,4 +1,8 @@
 from hyperpocket.session.interface import SessionStorageInterface
-from hyperpocket.util.find_all_leaf_class_in_package import find_all_leaf_class_in_package
+from hyperpocket.util.find_all_leaf_class_in_package import (
+    find_all_leaf_class_in_package,
+)
 
-SESSION_STORAGE_LIST = find_all_leaf_class_in_package("hyperpocket.session", SessionStorageInterface)
+SESSION_STORAGE_LIST = find_all_leaf_class_in_package(
+    "hyperpocket.session", SessionStorageInterface
+)

hyperpocket/session/in_memory.py

@@ -3,16 +3,22 @@ from typing import Dict, List, Optional
 
 from hyperpocket.auth import AuthProvider
 from hyperpocket.auth.context import AuthContext
-from hyperpocket.config.session import SessionConfigInMemory
-from hyperpocket.config.session import SessionType
-from hyperpocket.session.interface import SessionStorageInterface, SESSION_KEY_DELIMITER, \
-    BaseSessionValue, V, K
+from hyperpocket.config.session import SessionConfigInMemory, SessionType
+from hyperpocket.session.interface import (
+    SESSION_KEY_DELIMITER,
+    BaseSessionValue,
+    K,
+    SessionStorageInterface,
+    V,
+)
 
 InMemorySessionKey = str
 InMemorySessionValue = BaseSessionValue
 
 
-class InMemorySessionStorage(SessionStorageInterface[InMemorySessionKey, InMemorySessionValue]):
+class InMemorySessionStorage(
+    SessionStorageInterface[InMemorySessionKey, InMemorySessionValue]
+):
     # TODO(moon) : Force it to always take SessionConfig as an input
     def __init__(self, session_config: SessionConfigInMemory):
         super().__init__()
@@ -22,41 +28,54 @@ class InMemorySessionStorage(SessionStorageInterface[InMemorySessionKey, InMemor
     def session_storage_type(cls) -> SessionType:
         return SessionType.IN_MEMORY
 
-    def get(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> Optional[V]:
+    def get(
+        self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
+    ) -> Optional[V]:
         key = self._make_session_key(auth_provider.name, thread_id, profile)
         return self.storage.get(key, None)
 
-    def get_by_thread_id(self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs) -> List[V]:
+    def get_by_thread_id(
+        self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs
+    ) -> List[V]:
         if auth_provider is None:
             auth_provider_name = ".*"
         else:
             auth_provider_name = auth_provider.name
 
-        pattern = rf'{self._make_session_key(auth_provider_name, thread_id, ".*")}'
+        pattern = rf"{self._make_session_key(auth_provider_name, thread_id, '.*')}"
         compiled = re.compile(pattern)
 
-        session_list = [value for key, value in self.storage.items() if compiled.match(key)]
+        session_list = [
+            value for key, value in self.storage.items() if compiled.match(key)
+        ]
         return session_list
 
-    def set(self, auth_provider: AuthProvider,
-            thread_id: str,
-            profile: str,
-            auth_scopes: List[str],
-            auth_resolve_uid: Optional[str],
-            auth_context: Optional[AuthContext],
-            is_auth_scope_universal: bool, **kwargs) -> V:
+    def set(
+        self,
+        auth_provider: AuthProvider,
+        thread_id: str,
+        profile: str,
+        auth_scopes: List[str],
+        auth_resolve_uid: Optional[str],
+        auth_context: Optional[AuthContext],
+        is_auth_scope_universal: bool,
+        **kwargs,
+    ) -> V:
         key = self._make_session_key(auth_provider.name, thread_id, profile)
         session = self._make_session(
             auth_provider_name=auth_provider.name,
             auth_scopes=auth_scopes,
             auth_resolve_uid=auth_resolve_uid,
             auth_context=auth_context,
-            is_auth_scope_universal=is_auth_scope_universal)
+            is_auth_scope_universal=is_auth_scope_universal,
+        )
 
         self.storage[key] = session
         return session
 
-    def delete(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> bool:
+    def delete(
+        self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
+    ) -> bool:
         key = self._make_session_key(auth_provider.name, thread_id, profile)
         if key in self.storage:
             self.storage.pop(key)
@@ -75,15 +94,16 @@ class InMemorySessionStorage(SessionStorageInterface[InMemorySessionKey, InMemor
 
     @staticmethod
     def _make_session(
-            auth_provider_name: str,
-            auth_scopes: List[str],
-            auth_context: AuthContext,
-            auth_resolve_uid: str,
-            is_auth_scope_universal: bool) -> V:
+        auth_provider_name: str,
+        auth_scopes: List[str],
+        auth_context: AuthContext,
+        auth_resolve_uid: str,
+        is_auth_scope_universal: bool,
+    ) -> V:
         return InMemorySessionValue(
             auth_provider_name=auth_provider_name,
             auth_scopes=set(auth_scopes),
             auth_context=auth_context,
             auth_resolve_uid=auth_resolve_uid,
-            scoped=is_auth_scope_universal
+            scoped=is_auth_scope_universal,
         )

hyperpocket/session/interface.py

@@ -1,6 +1,6 @@
 import datetime
 from abc import ABC, abstractmethod
-from typing import TypeVar, Generic, List, Set, Optional, Iterable
+from typing import Generic, Iterable, List, Optional, Set, TypeVar
 
 from pydantic import BaseModel, Field
 
@@ -15,28 +15,37 @@ SESSION_KEY_DELIMITER = "__"
 
 class BaseSessionValue(BaseModel):
     auth_provider_name: str = Field(
-        description="The name of the authentication provider used to authenticate the current session")
+        description="The name of the authentication provider used to authenticate the current session"
+    )
     auth_context: Optional[AuthContext] = Field(
         default=None,
-        description="The authentication context containing the actual session details")
-    scoped: bool = Field(description="Indicates whether the current session is a scoped session")
+        description="The authentication context containing the actual session details",
+    )
+    scoped: bool = Field(
+        description="Indicates whether the current session is a scoped session"
+    )
     auth_scopes: Optional[Set[str]] = Field(
         default=None,
-        description="The authentication scopes of the current session, present only for scoped sessions")
+        description="The authentication scopes of the current session, present only for scoped sessions",
+    )
     auth_resolve_uid: Optional[str] = Field(
         default=None,
-        description="A UID used to asynchronously verify whether the user has completed the authentication process")
+        description="A UID used to asynchronously verify whether the user has completed the authentication process",
+    )
 
     def make_superset_auth_scope(
-            self,
-            other_scopes: Optional[Iterable[str]] = None) -> set[str]:
+        self, other_scopes: Optional[Iterable[str]] = None
+    ) -> set[str]:
         auth_scopes = self.auth_scopes or set()
         other_scopes = other_scopes or set()
         return auth_scopes.union(other_scopes)
 
-    def is_auth_applicable(self, auth_provider_name: str, auth_req: AuthenticateRequest) -> bool:
-        return self.auth_provider_name == auth_provider_name \
-            and (not self.scoped or self.auth_scopes.issuperset(auth_req.auth_scopes))
+    def is_auth_applicable(
+        self, auth_provider_name: str, auth_req: AuthenticateRequest
+    ) -> bool:
+        return self.auth_provider_name == auth_provider_name and (
+            not self.scoped or self.auth_scopes.issuperset(auth_req.auth_scopes)
+        )
 
     def is_near_expires(self) -> bool:
         if self.auth_context.expires_at is not None:
@@ -48,13 +57,15 @@ class BaseSessionValue(BaseModel):
         return False
 
 
-K = TypeVar('K')
-V = TypeVar('V', bound=BaseSessionValue)
+K = TypeVar("K")
+V = TypeVar("V", bound=BaseSessionValue)
 
 
 class SessionStorageInterface(ABC, Generic[K, V]):
     @abstractmethod
-    def get(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> V:
+    def get(
+        self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
+    ) -> V:
         """
         Get session
 
@@ -69,7 +80,9 @@ class SessionStorageInterface(ABC, Generic[K, V]):
         raise NotImplementedError
 
     @abstractmethod
-    def get_by_thread_id(self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs) -> List[V]:
+    def get_by_thread_id(
+        self, thread_id: str, auth_provider: Optional[AuthProvider] = None, **kwargs
+    ) -> List[V]:
         """
         Get session list by thread id
 
@@ -83,14 +96,17 @@ class SessionStorageInterface(ABC, Generic[K, V]):
         raise NotImplementedError
 
     @abstractmethod
-    def set(self,
-            auth_provider: AuthProvider,
-            thread_id: str,
-            profile: str,
-            auth_scopes: List[str],
-            auth_resolve_uid: Optional[str],
-            auth_context: Optional[AuthContext],
-            is_auth_scope_universal: bool, **kwargs) -> V:
+    def set(
+        self,
+        auth_provider: AuthProvider,
+        thread_id: str,
+        profile: str,
+        auth_scopes: List[str],
+        auth_resolve_uid: Optional[str],
+        auth_context: Optional[AuthContext],
+        is_auth_scope_universal: bool,
+        **kwargs,
+    ) -> V:
         """
         Set session, if a session doesn't exist, create new session
         If set auth_resolve_uid is None and auth_context is not None, created session is regarded as active session.
@@ -112,7 +128,9 @@ class SessionStorageInterface(ABC, Generic[K, V]):
         raise NotImplementedError
 
     @abstractmethod
-    def delete(self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs) -> bool:
+    def delete(
+        self, auth_provider: AuthProvider, thread_id: str, profile: str, **kwargs
+    ) -> bool:
         """
         Delete session