hyperpocket 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

hyperpocket/pocket_core.py

@@ -17,6 +17,7 @@ from hyperpocket.tool_like import ToolLike
 class PocketCore:
     auth: PocketAuth
     tools: dict[str, Tool]
+    lockfile: Lockfile
 
     def __init__(
         self,
@@ -29,48 +30,30 @@ class PocketCore:
             auth = PocketAuth()
         self.auth = auth
 
+        # init lockfile
         if lockfile_path is None:
             lockfile_path = "./pocket.lock"
         lockfile_pathlib_path = pathlib.Path(lockfile_path)
-        lockfile = Lockfile(lockfile_pathlib_path)
+        self.lockfile = Lockfile(lockfile_pathlib_path)
+
+        # parse tool_likes and add lock of the tool like to the lockfile
         tool_likes = []
         for tool_like in tools:
-            if isinstance(tool_like, str):
-                if pathlib.Path(tool_like).exists():
-                    lock = LocalLock(tool_like)
-                    req = WasmToolRequest(lock, "")
-                elif tool_like.startswith("https://github.com"):
-                    base_repo_url, git_ref, rel_path = GitLock.parse_repo_url(
-                        repo_url=tool_like
-                    )
-                    lock = GitLock(repository_url=base_repo_url, git_ref=git_ref)
-                    req = WasmToolRequest(lock=lock, rel_path=rel_path, tool_vars={})
-
-                lockfile.add_lock(lock)
-                tool_likes.append(req)
-            elif isinstance(tool_like, WasmToolRequest):
-                lockfile.add_lock(tool_like.lock)
-                tool_likes.append(tool_like)
-            elif isinstance(tool_like, ToolRequest):
-                raise ValueError(f"unreachable. tool_like:{tool_like}")
-            elif isinstance(tool_like, WasmTool):
-                raise ValueError("WasmTool should pass ToolRequest instance instead.")
-            else:
-                tool_likes.append(tool_like)
-        lockfile.sync(force_update=force_update, referenced_only=True)
+            parsed_tool_like = self._parse_tool_like(tool_like)
+            tool_likes.append(parsed_tool_like)
+            self._add_tool_like_lock_to_lockfile(parsed_tool_like)
+        self.lockfile.sync(force_update=force_update, referenced_only=True)
 
+        # load tool from tool_like
         self.tools = dict()
         for tool_like in tool_likes:
-            tool = self._load_tool(tool_like, lockfile)
-            if tool.name in self.tools:
-                pocket_logger.error(f"Duplicate tool name: {tool.name}.")
-                raise ValueError(f"Duplicate tool name: {tool.name}")
-            self.tools[tool.name] = tool
+            self._load_tool(tool_like)
 
         pocket_logger.info(
             f"All Registered Tools Loaded successfully. total registered tools : {len(self.tools)}"
         )
 
+        # load builtin tool
         builtin_tools = get_builtin_tools(self.auth)
         for tool in builtin_tools:
             self.tools[tool.name] = tool
@@ -266,17 +249,60 @@ class PocketCore:
     def _tool_instance(self, tool_name: str) -> Tool:
         return self.tools[tool_name]
 
-    @staticmethod
-    def _load_tool(tool_like: ToolLike, lockfile: Lockfile) -> Tool:
+    def _load_tool(self, tool_like: ToolLike) -> Tool:
         pocket_logger.info(f"Loading Tool {tool_like}")
         if isinstance(tool_like, Tool):
             tool = tool_like
         elif isinstance(tool_like, ToolRequest):
-            tool = Tool.from_tool_request(tool_like, lockfile=lockfile)
+            tool = Tool.from_tool_request(tool_like, lockfile=self.lockfile)
         elif isinstance(tool_like, Callable):
             tool = from_func(tool_like)
         else:
             raise ValueError(f"Invalid tool type: {type(tool_like)}")
 
+        if tool.name in self.tools:
+            pocket_logger.error(f"Duplicate tool name: {tool.name}.")
+            raise ValueError(f"Duplicate tool name: {tool.name}")
+        self.tools[tool.name] = tool
+
         pocket_logger.info(f"Complete Loading Tool {tool.name}")
         return tool
+
+    def _add_tool_like_lock_to_lockfile(self, tool_like: ToolLike):
+        if isinstance(tool_like, WasmToolRequest):  # lock is only in WasmToolRequest
+            self.lockfile.add_lock(tool_like.lock)
+        return
+
+    @classmethod
+    def _parse_tool_like(cls, tool_like: ToolLike) -> ToolLike:
+        if isinstance(tool_like, str):
+            return cls._parse_str_tool_like(tool_like)
+
+        elif isinstance(tool_like, WasmToolRequest):
+            return tool_like
+
+        elif isinstance(tool_like, ToolRequest):
+            raise ValueError(f"unreachable. tool_like:{tool_like}")
+        elif isinstance(tool_like, WasmTool):
+            raise ValueError("WasmTool should pass ToolRequest instance instead.")
+        else:  # Callable, Tool
+            return tool_like
+
+    @classmethod
+    def _parse_str_tool_like(cls, tool_like: str) -> ToolLike:
+        if pathlib.Path(tool_like).exists():
+            lock = LocalLock(tool_like)
+            parsed_tool_like = WasmToolRequest(lock=lock, rel_path="", tool_vars={})
+        elif tool_like.startswith("https://github.com"):
+            base_repo_url, git_ref, rel_path = GitLock.parse_repo_url(
+                repo_url=tool_like
+            )
+            lock = GitLock(repository_url=base_repo_url, git_ref=git_ref)
+            parsed_tool_like = WasmToolRequest(lock=lock, rel_path=rel_path, tool_vars={})
+        else:
+            parsed_tool_like = None
+            RuntimeError(
+                f"Can't convert to ToolRequest. it might be wrong github url or local path. path: {tool_like}")
+
+        return parsed_tool_like
+

hyperpocket/pocket_main.py

@@ -1,5 +1,4 @@
 import asyncio
-from concurrent.futures import ThreadPoolExecutor
 from typing import Any, List, Optional, Union
 
 from hyperpocket.config import pocket_logger
@@ -90,6 +89,7 @@ class Pocket(object):
             *args,
             **kwargs,
         )
+        pocket_logger.debug(f"{tool_name} result: {result}")
         return result
 
     def invoke_with_state(

hyperpocket-0.3.1.dist-info/METADATA

@@ -0,0 +1,377 @@
+Metadata-Version: 2.4
+Name: hyperpocket
+Version: 0.3.1
+Summary: Building AI agent with hyperpocket tool in a flash
+Project-URL: Homepage, https://vessl-ai.github.io/hyperpocket
+Project-URL: Repository, https://github.com/vessl-ai/hyperpocket
+Author-email: Hyperpocket Team <hyperpocket@vessl.ai>
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.7
+Requires-Dist: dynaconf>=3.2.6
+Requires-Dist: fastapi>=0.115.5
+Requires-Dist: gitpython>=3.1.43
+Requires-Dist: httpx==0.27
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: multiprocess>=0.70.17
+Requires-Dist: playwright>=1.49.0
+Requires-Dist: pydantic>=2.10.2
+Requires-Dist: pygithub>=2.5.0
+Requires-Dist: python-multipart>=0.0.19
+Requires-Dist: redis>=5.2.1
+Requires-Dist: requests>=2.32.3
+Requires-Dist: toml>=0.10.2
+Requires-Dist: uvicorn>=0.32.1
+Description-Content-Type: text/markdown
+
+<p align="center">
+<img src="logo.png" alt="hyperpocket" width="570"/>
+</p>
+
+# Hyperpocket 👛
+
+Hyperpocket is where tools belong. Power your agent up with a pocket of tools. 👛
+
+## Introduction
+
+Hyperpocket is a tool that allows you to easily use tool and auth for agents on your machine.
+
+**_Start fast._** Just install Hyperpocket and use it. We know you don't have time to authenticate to our server.
+
+**_Go securely._** Not like others, you are the only one who knows your secret tokens. We do NOT. All of your secret
+tokens belong to your infrastructure, not ours.
+
+**_Power up with public tools._** Without worries for tool integration, use others' tools just with copy-and-paste the
+link to the tool. Your tool will run on isolated environment based on WebAssembly technology, and you don't have to deal
+with the dependency spaghetti.
+
+**_Battery Included_** You can use popular tools and authentication providers out-of-the-box.
+
+## Getting Started
+
+getting started langchain tool-calling-agent example with hyperpocket
+
+### 1. Prerequisite
+
+install hyperpocket package
+
+```shell
+pip install hyperpocket_langchain
+pip install langchain_openai
+```
+
+install playwright
+
+```shell
+playwright install
+```
+
+### 2. Configuration
+
+setting hyperpocket config in your current working directory
+
+`${WORKDIR}/.secret.toml`
+
+```toml
+[auth.slack]
+client_id = "<SLACK_CLIENT_ID>"
+client_secret = "<SLACK_CLIENT_SECRET>"
+```
+
+setting openai api key env for this example.
+
+```shell
+export OPENAI_API_KEY=<OPENAI_API_KEY>
+```
+
+### 3. Writing code
+
+`langchain_example.py`
+
+```python
+import os
+
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain.memory import ConversationBufferMemory
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_openai import ChatOpenAI
+
+from hyperpocket_langchain import PocketLangchain
+
+if __name__ == '__main__':
+    pocket = PocketLangchain(
+        tools=[
+            "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+            "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+        ],
+    )
+    tools = pocket.get_tools()
+    llm = ChatOpenAI(model="gpt-4o", api_key=os.getenv("OPENAI_API_KEY"))
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            (
+                "system",
+                "You are a tool calling assistant. You can help the user by calling proper tools",
+            ),
+            ("placeholder", "{chat_history}"),
+            ("user", "{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ]
+    )
+
+    memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+    agent = create_tool_calling_agent(llm, tools, prompt)
+    agent_executor = AgentExecutor(
+        agent=agent,
+        tools=tools,
+        memory=memory,
+        verbose=True,
+        handle_parsing_errors=True,
+    )
+
+    print("Hello, This is simple slack agent using hyperpocket.")
+    while True:
+        print("user(q to quit) : ", end="")
+        user_input = input()
+
+        if user_input is None or user_input == "":
+            continue
+        elif user_input == "q":
+            print("Good bye!")
+            break
+
+        response = agent_executor.invoke({"input": user_input})
+        print("agent : ", response["output"])
+        print()
+```
+
+### 4. Done !
+
+```shell
+python langchain_example.py
+```
+
+## Usage
+
+Supported agent frameworks
+
+- [x] Langgraph [link](https://www.langchain.com/langgraph)
+- [x] Langchain [link](https://www.langchain.com/)
+- [x] Llamaindex [link](https://www.llamaindex.ai/)
+
+Or just use LLM API Clients out of the box.
+
+- [x] OpenAI [link](https://openai.com/)
+- [x] Anthropic [link](https://www.anthropic.com/)
+
+### Using out-of-the-box tools
+
+```python
+
+from langchain_openai import ChatOpenAI
+
+from hyperpocket_langchain import PocketLangchain
+
+pklc = PocketLangchain(
+    tools=[
+        "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+        "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+    ]
+)
+tools = pklc.get_tools()
+
+llm = ChatOpenAI()
+llm_tool_binding = llm.bind_tools(tools)
+llm_tool_binding.invoke(...)
+```
+
+### Using out-of-the-box auth for various tools
+
+There are two kinds of auth process, one is using system auth(developer api key) and the other is using end user auth.
+
+Pocket provides way to use end user auth easily.
+(Of course, you can also just set your STRIPE_API_KEY when using Stripe API related tools)
+
+- Supported methods
+
+    - [x] OAuth
+    - [x] Token
+    - [ ] Basic Auth (Username, Password)
+
+- Supported OAuth Providers
+
+    - [x] Google
+    - [x] GitHub
+    - [x] Slack
+    - [x] Reddit
+    - [x] Calendly
+    - [ ] Facebook
+    - [ ] X (Previously Twitter)
+    - [ ] LinkedIn
+    - [ ] Discord
+    - [ ] Zoom
+    - [ ] Microsoft
+    - [ ] Spotify
+    - [ ] Twitch
+
+- Supported Token Providers
+    - [x] Notion
+    - [x] Slack
+    - [x] Linear
+    - [x] Gumloop
+    - [x] Github
+
+You can manage your auths in request-wise level. (e.g. you can use different auths for different requests)
+
+```python
+
+from langchain_openai import ChatOpenAI
+from langgraph.graph import StateGraph, START, MessagesState
+from langgraph.prebuilt import tools_condition
+
+from hyperpocket_langgraph import PocketLanggraph
+
+pklg = PocketLanggraph(
+    tools=[
+        "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+        "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+    ],
+)
+llm = ChatOpenAI()
+
+# Langgraph
+pk_tool_node = pklg.get_tool_node()
+llm_tool_binding = llm.bind_tools(pklg.get_tools())
+
+# ...
+
+graph_builder = StateGraph(MessagesState)
+
+graph_builder.add_node('llm', llm)
+graph_builder.add_node('tools', pk_tool_node)
+graph_builder.add_edge(START, llm)
+graph_builder.add_conditional_edges("llm", tools_condition)
+graph_builder.add_edge(pk_tool_node, llm)
+
+# ...
+
+graph_builder.compile()
+
+```
+
+```python
+import os
+
+from llama_index.core.agent import FunctionCallingAgent
+from llama_index.llms.openai import OpenAI
+
+from hyperpocket_llamaindex import PocketLlamaindex
+
+llm = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+pocket = PocketLlamaindex(
+    tools=[
+        "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/get-message",
+        "https://github.com/vessl-ai/hyperpocket/tree/main/tools/slack/post-message",
+        "https://github.com/vessl-ai/hyperpocket/tree/main/tools/linear/get-issues",
+        "https://github.com/vessl-ai/hyperpocket/tree/main/tools/google/get-calendar-events",
+        "https://github.com/vessl-ai/hyperpocket/tree/main/tools/google/get-calendar-list",
+    ]
+)
+tools = pocket.get_tools()
+
+agent = FunctionCallingAgent.from_tools(tools=tools, llm=llm)
+```
+
+### Auth flow included
+
+```text
+Human: List my slack messages in 'general' channel
+
+Assistance: It looks like you need to authenticate to access the Slack messages. Please use [this link](https://slack.com/oauth/v2/authorize?user_scope=SCOPES&client_id=CLIENT_ID&redirect_uri=REDIRECT_URL) to authenticate your Slack account, and then let me know when you're done!
+
+Human: done.
+
+Assistance: Here are the recent 10 messages.
+(...)
+```
+
+### Config
+
+Running `hyperpocket config init` will create your config file in `${WORKDIR}/settings.toml` and
+`${WORKDIR}/.secrets.toml`
+
+The `settings.toml` looks as follows.
+
+```toml
+log_level = "debug"
+internal_server_port = "8000" # optional, default is 8000
+public_hostname = "localhost" # optional, default is localhost
+public_server_protocol = "https" # optional, default is https
+public_server_port = "8001" # optional, default is 8001
+enable_local_callback_proxy = "true" # optional, default is true, can be turned off when running in production behind TLS termination
+callback_url_rewrite_prefix = "proxy" # optional, default is proxy, auth callback url prefix
+
+[session]
+session_type = "redis" # optional, default is in-memory
+[session.redis]
+host = "localhost"
+port = 6379
+db = 0
+
+[auth.slack] # add your slack app's client id and secret for slack auth
+client_id = "" # your slack client id
+client_secret = "" # your slack client secret
+```
+
+Or you put some sensitive data on `{WORKDIR}/.secrets.toml`
+
+```toml
+[auth.slack] # add your slack app's client id and secret for slack auth
+client_id = "" # your slack client id
+client_secret = "" # your slack client secret
+```
+
+- in this case, by putting your slack app client_id and client_secret on `.secrets.toml`, you can manage your sensitive
+  data more safely.
+
+#### How to integrate github OAuth app
+
+1. Follow the github documentation to create a new OAuth
+   app. https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/creating-an-oauth-app
+
+- While creating your github OAuth app, configuring your app's `Authorization callback URL` is different for your
+  development environment and production environment.
+    - For local testing environment, you can use `https://localhost:8001/proxy/auth/<provider>/callback` for TLS enabled
+      redirect url. (ex. `https://localhost:8001/proxy/auth/github/callback`)
+        - **Note**: Default port for hyperpocket dev server is `8000`. If you are using a different port, make sure to
+          replace `8000` with your actual port number.
+        - **Note**: But for easy dev experience, you can use TLS proxy on port `8001` provided out-of-the-box.
+            - You can change the `proxy` prefix in settings.toml to your desired prefix with
+              `callback_url_rewrite_prefix` key.
+    - For production environment, you can use `https://yourdomain.com/auth/github/callback`
+        - **Note**: Make sure to replace `yourdomain.com` with your actual domain name that this app will be hosted on.
+
+#### How to integrate SLACK OAuth app
+
+1. Follow the slack documentation to create a new Oauth APP. https://api.slack.com/quickstart
+
+2. Setting Redirect URLs, Scopes at OAuth & Permissions tap in slack APP page
+
+- Redirect URLs :
+  `{public_server_protocol}://{public_hostname}:[{public_server_port}]/{callback_url_rewrite_prefix}/auth/slack/oauth2/callback`
+- Scopes : What you want to request to user.
+    - Recommended scopes :
+        - channels:history,
+        - channels:read,
+        - chat:write,
+        - groups:history,
+        - groups:read,
+        - im:history,
+        - mpim:history,
+        - reactions:read,
+        - reactions:write,
+
+3. Set your Slack APP Client ID / Client Secret in `{WORKDIR}/settings.toml`
+
+## Special thanks
+
+- [tott](https://x.com/tott____) for drawing the cute possum in a pocket.

{hyperpocket-0.2.1.dist-info → hyperpocket-0.3.1.dist-info}/RECORD

@@ -2,8 +2,8 @@ hyperpocket/__init__.py,sha256=VVLbApRTiULqEVQp6lCNOcuXKx9V62O_7C9VNKBQ0G0,137
 hyperpocket/builtin.py,sha256=SOrVrNjoKadDMksfB1rt6pKreJFzHG2YGBsLGVsg72c,2385
 hyperpocket/constants.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hyperpocket/pocket_auth.py,sha256=VzpGpHOOQIiEgrk1sYg5DYa5WYV6gRQmFlm8Kb2C9V0,17611
-hyperpocket/pocket_core.py,sha256=lfACm6xCQAg5pJnPkt6TpSmAkGmX1RN9oc_DAputLME,10252
-hyperpocket/pocket_main.py,sha256=uR3RJmsNBt4XDu5EgCRsKWTR5dkHjXIOjJ2Y3KO7zUA,9617
+hyperpocket/pocket_core.py,sha256=URghKdbgAhPWyN-n9hAWmst_bB4J08YVlDQPDBz0R0g,11039
+hyperpocket/pocket_main.py,sha256=ZSj0107pBBXx_pFKzggjEpm68Y1tQpDyYc2O_QDb4qQ,9628
 hyperpocket/prompts.py,sha256=N1bCzCLZvGUVhH1Vn_cgeBPsdY3MdIU7ZGqVgexoj5E,472
 hyperpocket/tool_like.py,sha256=5JgHZFEFu-GcZZl5pwkUqHeABUpN3nyJdtKJHtEjpHU,135
 hyperpocket/auth/README.md,sha256=zn4QqnFZCA_4X3x8Wb6lE3OP5otYxpByZaCiUkBvaNs,11562
@@ -49,29 +49,33 @@ hyperpocket/auth/notion/token_schema.py,sha256=ksBNQa2KCyjXZ3z9NB1Sgp0VBRR6nrddM
 hyperpocket/auth/reddit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hyperpocket/auth/reddit/context.py,sha256=WlOvIb4u1PvfrbkYbEq5cSRnXxmIEFuHa4LlKjLEtMc,431
 hyperpocket/auth/reddit/oauth2_context.py,sha256=v1u_uy6O52REp2anteTPNgvb_nX-hI6bM7jNngBZXq4,1015
-hyperpocket/auth/reddit/oauth2_handler.py,sha256=BJcHqsb4P3Nky_QMOGq5qkcZ943FvUSMDkkiMltXUyY,5212
+hyperpocket/auth/reddit/oauth2_handler.py,sha256=X_lzoyhYnjEFriBuorGdn977uD5GjphPiXi8W9SYdy0,5166
 hyperpocket/auth/reddit/oauth2_schema.py,sha256=MOcA8VTvjjwewxhyIn_-DRNf6H_5GjsN6C7gV8sDyiI,436
 hyperpocket/auth/slack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hyperpocket/auth/slack/context.py,sha256=f8dMs7QtSSyissOlPGw8rCZXsVUckFnZWjZ_LAmNXpA,429
 hyperpocket/auth/slack/oauth2_context.py,sha256=kwahsgxtDo5Wg_nrF8mFv16ijIu6biiGe_qz2JlEKjM,1398
-hyperpocket/auth/slack/oauth2_handler.py,sha256=TtrJtEZgrA9kwhYtanxsdJjW0axVbIfpAqqSRRm9QrA,6145
+hyperpocket/auth/slack/oauth2_handler.py,sha256=Mm9aSZoXFz8_Ua37JI9uJQrKgBXRo_1tJ1AGwtSQ0ZQ,6099
 hyperpocket/auth/slack/oauth2_schema.py,sha256=eu2jF2thmaz66AKcnivTvIBLTbeF-a-xQFMkR4RQYX8,1056
 hyperpocket/auth/slack/token_context.py,sha256=GUqMcPUleo8O9YRNMjOrMiSlHb-OOKwlrO_syCow55w,437
 hyperpocket/auth/slack/token_handler.py,sha256=6L_HiDQ2wpz9x65QUB9t-d5KOpADeG-zZVgEMHu3MUE,2765
 hyperpocket/auth/slack/token_schema.py,sha256=mAwOtRO2tW5OtDzbllDJtR_uhLD8ShQAjezkAZnAgd0,207
 hyperpocket/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hyperpocket/cli/__main__.py,sha256=SpymRzsYBcW2C9Llzq-bjnuIszweq1r6-ili0mOZM-M,418
-hyperpocket/cli/auth.py,sha256=wLzv0g-MdMtzSPKVuqUeZn_O4hKcyOpcp78RvxKkWbI,4364
+hyperpocket/cli/__main__.py,sha256=68fOHIx2zw_k_ncR6PR8S9iZG_yQkPG7yAOj428Op_M,580
+hyperpocket/cli/auth_oauth2.py,sha256=gGQCS8AvaVHvs4Oe6fS7tw2ks_N67-8newinaDlywbw,4680
+hyperpocket/cli/auth_token.py,sha256=gmT-jVMvZ1Ck-1F_yFUChcd9HMtFHNTaUvj_332usjE,4809
 hyperpocket/cli/eject.py,sha256=Te1YhDONk_VCgZ6l2HjLqONJrn04EfPk19sD6D5SOyY,636
 hyperpocket/cli/pull.py,sha256=3xCyTmdbP77l7awNyCY63_ZmUhIlX1PE3apwReXNYco,549
 hyperpocket/cli/sync.py,sha256=OO5zFrLOMXk7TSAFEew04ZzW4HLoQ1uVb80UKvIJha0,517
 hyperpocket/cli/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hyperpocket/cli/codegen/auth/__init__.py,sha256=1R2FwRuReAWyeRe1t3-CpR0Mhvb3xWzF8fEkL2mwuB0,545
+hyperpocket/cli/codegen/auth/__init__.py,sha256=wtm3vX2Kk79tyFkguV5oV82_YoJ3w-Clqu2izwE65Vg,959
 hyperpocket/cli/codegen/auth/auth_context_template.py,sha256=89HHp5byHhLazkwtR8bsymg7IBKfp2ltdGikcD5aplY,570
+hyperpocket/cli/codegen/auth/auth_oauth2_context_template.py,sha256=IW7zevhpR9W4ghUhjfRrzhxMBKLdVuzUHn6E6kB2gVU,1391
+hyperpocket/cli/codegen/auth/auth_oauth2_handler_template.py,sha256=Aed6_zt5aa0aAjhrfvuspGK_4GtcsT3McoWeIGIBmKo,6761
+hyperpocket/cli/codegen/auth/auth_oauth2_schema_template.py,sha256=GEp0jHNJnQZ6okyofxKBdaOIyeR8-qu_1OY1wAav9Mo,535
 hyperpocket/cli/codegen/auth/auth_token_context_template.py,sha256=GzpsCY6DlGXu-YxMaJ1vtesHfJxRvQ6hEb4Xodl8EB0,764
 hyperpocket/cli/codegen/auth/auth_token_handler_template.py,sha256=t30JZFTCYCcXWFop4CVEABEtttjJn-F6tcS-ZOQCh-Y,3158
 hyperpocket/cli/codegen/auth/auth_token_schema_template.py,sha256=ZJRcT-0QIIxltkDCgVz7zKl3aObX__bMi33s7_ZxI5k,429
-hyperpocket/cli/codegen/auth/server_auth_template.py,sha256=ed_8hTPSLzKdhdA52UoWigzYW4jQKlNGxO7B6LKNY_A,621
+hyperpocket/cli/codegen/auth/server_auth_template.py,sha256=-S3bqlqsXMytOdrIG68_np3LfU5_Ydy7z-Z0fqfCE8I,1478
 hyperpocket/config/__init__.py,sha256=gYMHdExdPYScBB8mihSp1yJ9H-RJ8FdNz5mEFubFNAo,138
 hyperpocket/config/auth.py,sha256=IsHQHiwPmO5afbmwkA1lA1P7zF7W6LmXpM4ZmUZ4c-E,795
 hyperpocket/config/git.py,sha256=CGbY7J1LyN4ccZr9CFGAQwwhjC9kvdU0On_nsAsZ1FQ,362
@@ -131,7 +135,7 @@ hyperpocket/util/flatten_json_schema.py,sha256=iuNBEmMSKFtPi-uqo6fb3RWN0koHOAihW
 hyperpocket/util/function_to_model.py,sha256=TXUs-qPbzL8C9-qqpz4Ad4D9MOPP61n_p0iPU6SoBeM,2318
 hyperpocket/util/get_objects_from_subpackage.py,sha256=4mR_S8eaJSdU68YfCkiXeIcXxb6q7LjFGsY_IHeNIZw,929
 hyperpocket/util/json_schema_to_model.py,sha256=PqI87pU5dWwcrQWB8eQxRdfgAEvvC1x_DKZnhcsRV-o,3586
-hyperpocket-0.2.1.dist-info/METADATA,sha256=h_QFqmweEXplG8WQ0QS8A3tT8DVC2--lafQ6FwUG2Ms,9689
-hyperpocket-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hyperpocket-0.2.1.dist-info/entry_points.txt,sha256=KpBleaYr0SaENXOa-dFvJ_cvFCHYFEQ4LMl11ShAcBI,61
-hyperpocket-0.2.1.dist-info/RECORD,,
+hyperpocket-0.3.1.dist-info/METADATA,sha256=UEJCp-ThPh9eJOzGYyOulcb7QD7shB14LvzMm9tLnL4,11430
+hyperpocket-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hyperpocket-0.3.1.dist-info/entry_points.txt,sha256=KpBleaYr0SaENXOa-dFvJ_cvFCHYFEQ4LMl11ShAcBI,61
+hyperpocket-0.3.1.dist-info/RECORD,,