python-fastllm 0.0.47__tar.gz → 0.0.48__tar.gz

{python_fastllm-0.0.47 → python_fastllm-0.0.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fastllm
-Version: 0.0.47
+Version: 0.0.48
 Author-email: Kerem Turgutlu <keremturgutlu@gmail.com>
 License: Apache-2.0
 Project-URL: Repository, https://github.com/AnswerDotAI/fastllm

{python_fastllm-0.0.47 → python_fastllm-0.0.48}/fastllm/__init__.py

@@ -2,4 +2,4 @@
 
 - `fastllm.responses`: Provider-independent Responses resources and streaming over FastLLM"""
 
-__version__ = "0.0.47"
+__version__ = "0.0.48"

{python_fastllm-0.0.47 → python_fastllm-0.0.48}/fastllm/_modidx.py

@@ -120,7 +120,22 @@ d = { 'settings': { 'branch': 'main',
                               'fastllm.chat.stop_reason': ('chat.html#stop_reason', 'fastllm/chat.py'),
                               'fastllm.chat.structured': ('chat.html#structured', 'fastllm/chat.py'),
                               'fastllm.chat.think_sep': ('chat.html#think_sep', 'fastllm/chat.py')},
-            'fastllm.codex': {},
+            'fastllm.codex': { 'fastllm.codex._merge_tokens': ('codex.html#_merge_tokens', 'fastllm/codex.py'),
+                               'fastllm.codex._post': ('codex.html#_post', 'fastllm/codex.py'),
+                               'fastllm.codex._token_grant': ('codex.html#_token_grant', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_auth': ('codex.html#codex_auth', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_auth_path': ('codex.html#codex_auth_path', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_device_code': ('codex.html#codex_device_code', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_device_tokens': ('codex.html#codex_device_tokens', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_info': ('codex.html#codex_info', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_login': ('codex.html#codex_login', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_refresh': ('codex.html#codex_refresh', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_token': ('codex.html#codex_token', 'fastllm/codex.py'),
+                               'fastllm.codex.codex_tokens': ('codex.html#codex_tokens', 'fastllm/codex.py'),
+                               'fastllm.codex.jwt_claims': ('codex.html#jwt_claims', 'fastllm/codex.py'),
+                               'fastllm.codex.main': ('codex.html#main', 'fastllm/codex.py'),
+                               'fastllm.codex.mk_jwt': ('codex.html#mk_jwt', 'fastllm/codex.py'),
+                               'fastllm.codex.token_expired': ('codex.html#token_expired', 'fastllm/codex.py')},
             'fastllm.gemini': { 'fastllm.gemini._gem_filter_sch': ('gemini.html#_gem_filter_sch', 'fastllm/gemini.py'),
                                 'fastllm.gemini._gem_part_type': ('gemini.html#_gem_part_type', 'fastllm/gemini.py'),
                                 'fastllm.gemini.acollect_stream': ('gemini.html#acollect_stream', 'fastllm/gemini.py'),

{python_fastllm-0.0.47 → python_fastllm-0.0.48}/fastllm/acomplete.py

@@ -13,6 +13,7 @@ from fasttransport.core import AsyncHttpCli
 from fasttransport.errors import APIError
 
 from .types import *
+from .codex import codex_auth_path
 from aidialog.msg_parts import (Part, PartType, Msg, Text, Thinking, ToolUse, ToolResult, InputImage, InputAudio, InputVideo,
     InputFile, mk_tool_res_msg, Completion)
 from .streaming import *
@@ -22,7 +23,7 @@ from .anthropic import *
 from .gemini import *
 
 # %% ../nbs/06_acomplete.ipynb #32ee2546
-_codex_path = os.getenv('CODEX_AUTH_PATH', '~/.codex/auth.json')
+_codex_path = codex_auth_path()
 _codex_json = _codex_path, ('tokens','access_token')
 vendor_mapping = {
     "openai":       ('openai', 'https://api.openai.com/v1', 'OPENAI_API_KEY'),
@@ -162,7 +163,9 @@ async def acomplete(msgs, model, api_name=None, vendor_name=None, api_key=None,
         if v in vendor_mapping: vendor_name, model = v, m
         elif v: api_name, model = v, m  # a registered transport api (e.g. claude_code): not an HTTP vendor
     own = api_name in api_registry and not hasattr(api_registry[api_name], 'endpoint') if api_name else False
-    if own: vendor_name = ifnone(vendor_name, api_name)  # an own-transport api: no HTTP client to build
+    if own:
+        vendor_name = ifnone(vendor_name, api_name)  # an own-transport api: no HTTP client to build
+        if api_key: kwargs['api_key'] = api_key  # its `mk_payload` applies a per-user credential itself
     else: cli, api_name, vendor_name = mk_client(model=model, vendor_name=vendor_name, api_name=api_name, api_key=api_key, base_url=base_url, xtra_hdrs=xtra_hdrs)
     api = api_registry[api_name]
     if previous_response_id is not None:

python_fastllm-0.0.48/fastllm/codex.py

@@ -0,0 +1,118 @@
+"""ChatGPT subscription tokens for the Codex backend"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/05_codex.ipynb.
+
+# %% auto #0
+__all__ = ['SKEW_SECS', 'jwt_claims', 'mk_jwt', 'token_expired', 'codex_tokens', 'codex_info', 'codex_refresh', 'codex_token',
+           'codex_auth_path', 'codex_auth', 'codex_device_code', 'codex_device_tokens', 'codex_login', 'main']
+
+# %% ../nbs/05_codex.ipynb #a1d088d2
+import asyncio, base64, json, sys, time, httpx2
+from fastcore.aio import wait_until
+from fastcore.utils import *
+
+
+# %% ../nbs/05_codex.ipynb #aa7f9d4f
+_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann'
+_AUTH = 'https://auth.openai.com'
+SKEW_SECS = 60
+
+# %% ../nbs/05_codex.ipynb #2008472d
+def jwt_claims(token):
+    "The payload of JWT `token`, decoded without verification"
+    payload = token.split('.')[1]
+    return json.loads(base64.urlsafe_b64decode(payload + '='*(-len(payload)%4)))
+
+# %% ../nbs/05_codex.ipynb #fdba8e96
+def mk_jwt(**claims):
+    "An unsigned JWT carrying `claims`, shaped like an access token; for examples and tests"
+    enc = lambda o: base64.urlsafe_b64encode(json.dumps(o).encode()).decode().rstrip('=')
+    return f"{enc(dict(alg='RS256', typ='JWT'))}.{enc(claims)}.sig"
+
+# %% ../nbs/05_codex.ipynb #6b6a339d
+def token_expired(token, skew=SKEW_SECS):
+    "Is JWT `token` expired, or within `skew` seconds of expiring?"
+    try: exp = jwt_claims(token)['exp']
+    except (ValueError, KeyError, IndexError): return True
+    return time.time() >= exp - skew
+
+# %% ../nbs/05_codex.ipynb #099399d5
+def codex_tokens(auth):
+    "The `tokens` block of an `auth.json` dict (or an already-unwrapped block), checked for the keys a refresh needs"
+    if not isinstance(auth, dict): raise ValueError('Codex auth must be a JSON object')
+    tokens = auth.get('tokens', auth)
+    missing = [k for k in ('access_token', 'refresh_token') if not tokens.get(k)]
+    if missing: raise ValueError(f"Codex auth is missing {', '.join(missing)}")
+    return tokens
+
+# %% ../nbs/05_codex.ipynb #46864051
+def codex_info(tokens):
+    "Plan type and expiry time of the access token in `tokens`"
+    claims = jwt_claims(tokens['access_token'])
+    return dict(plan=claims.get('https://api.openai.com/auth', {}).get('chatgpt_plan_type'), expires=claims.get('exp'))
+
+# %% ../nbs/05_codex.ipynb #28410636
+async def _post(path, form=False, **body):
+    "POST `body` to the OpenAI auth server at `path`, as a form or as JSON, returning the JSON reply"
+    async with httpx2.AsyncClient() as cli: r = await cli.post(f'{_AUTH}{path}', **(dict(data=body) if form else dict(json=body)))
+    r.raise_for_status()
+    return r.json()
+
+def _merge_tokens(tokens, new): return {**tokens, **{k: new[k] for k in ('access_token', 'id_token', 'refresh_token') if k in new}}
+
+async def _token_grant(tokens, form=False, **grant):
+    "The token block after `grant` at the token endpoint, merged over `tokens`; the exchange of a sign-in code is form-encoded, a refresh JSON"
+    return _merge_tokens(tokens, await _post('/oauth/token', form=form, client_id=_CLIENT_ID, **grant))
+
+# %% ../nbs/05_codex.ipynb #48efd465
+async def codex_refresh(tokens):
+    "Exchange the refresh token in `tokens` for a new token block"
+    return await _token_grant(tokens, grant_type='refresh_token', refresh_token=tokens['refresh_token'], scope='openid profile email')
+
+# %% ../nbs/05_codex.ipynb #be590818
+async def codex_token(tokens, force_refresh=False):
+    "A valid access token from `tokens`, and the refreshed block to store when a refresh happened (else `None`)"
+    if not force_refresh and not token_expired(tokens['access_token']): return tokens['access_token'], None
+    tokens = await codex_refresh(tokens)
+    return tokens['access_token'], tokens
+
+# %% ../nbs/05_codex.ipynb #ea6c1e6a
+def codex_auth_path(): return Path(os.environ.get('CODEX_AUTH_PATH', '~/.codex/auth.json')).expanduser()
+
+async def codex_auth(force_refresh=False):
+    "A valid access token from the local Codex login, refreshing the file when needed"
+    path = codex_auth_path()
+    data = json.loads(path.read_text())
+    token,new = await codex_token(codex_tokens(data), force_refresh)
+    if new: path.write_text(json.dumps({**data, 'tokens':new}, indent=2))
+    return token
+
+# %% ../nbs/05_codex.ipynb #216c81ae
+_DEVICE = '/api/accounts/deviceauth'
+async def codex_device_code():
+    "Start a device sign-in: the page and code to show the user, and what the poll needs"
+    r = await _post(f'{_DEVICE}/usercode', client_id=_CLIENT_ID)
+    return dict(url=f'{_AUTH}/codex/device', code=r['user_code'], device_auth_id=r['device_auth_id'], interval=int(r.get('interval') or 5))
+
+# %% ../nbs/05_codex.ipynb #9ada6ae8
+async def codex_device_tokens(dev, timeout=15*60):
+    "Wait for the user to enter the code from `dev`, then exchange the grant for a token block"
+    async def _poll():
+        try: return await _post(f'{_DEVICE}/token', device_auth_id=dev['device_auth_id'], user_code=dev['code'])
+        except httpx2.HTTPStatusError as e:
+            if e.response.status_code in (403, 404): return None
+            raise
+    grant = await wait_until(_poll, 'the sign-in to complete', timeout, sleep=dev['interval'])
+    return await _token_grant({}, form=True, grant_type='authorization_code', code=grant['authorization_code'], redirect_uri=f'{_AUTH}/deviceauth/callback',
+        code_verifier=grant['code_verifier'])
+
+# %% ../nbs/05_codex.ipynb #0ca00e36
+async def codex_login():
+    "Sign in to ChatGPT with a device code, returning the token block"
+    dev = await codex_device_code()
+    print(f"Open {dev['url']} and enter the code {dev['code']}", file=sys.stderr)
+    return await codex_device_tokens(dev)
+
+def main():
+    "`fastllm-auth`: sign in to ChatGPT and print the token block"
+    print(json.dumps(asyncio.run(codex_login())))

{python_fastllm-0.0.47 → python_fastllm-0.0.48}/fastllm/responses.py

@@ -148,9 +148,10 @@ class ResponseState(BasicRepr):
 # %% ../nbs/06a_responses.ipynb #c9ca3744
 class ResponseTurn(BasicRepr):
     "A prepared Responses request for one provider call."
-    def __init__(self, id, created_at, body, history, provider_messages, system='', previous=None, server_tools=None):
+    def __init__(self, id, created_at, body, history, provider_messages, system='', previous=None, server_tools=None, call_kwargs=None):
         store_attr()
         if server_tools is None: self.server_tools = {}
+        if call_kwargs is None: self.call_kwargs = {}
 
     @property
     def provider_previous_id(self): return self.previous.provider_response_id if self.previous else None
@@ -159,7 +160,7 @@ class ResponseTurn(BasicRepr):
 # %% ../nbs/06a_responses.ipynb #a648297f
 class AsyncResponses:
     "Run individual Responses turns over FastLLM."
-    def prepare(self, body, previous=None, server_tools=None):
+    def prepare(self, body, previous=None, server_tools=None, **kwargs):
         if not isinstance(body, dict): raise ResponsesError('Request body must be an object')
         model = body.get('model')
         if not model: raise ResponsesError('model is required', param='model')
@@ -174,13 +175,13 @@ class AsyncResponses:
         instructions = '\n\n'.join(filter(None, [body.get('instructions', ''), input_system]))
         provider_messages = new_msgs if previous and previous.provider_response_id else list(history)
         return ResponseTurn(_new_id('resp'), int(time.time()), body, history, provider_messages, instructions, previous,
-            {f.__name__: f for f in server_tools or []})
+            {f.__name__: f for f in server_tools or []}, kwargs)
 
 
 # %% ../nbs/06a_responses.ipynb #373f7d5e
 @patch
 async def call(self:AsyncResponses, turn):
-    "Start the provider stream for a prepared turn, having received its first chunk"
+    "Start the provider stream for a prepared turn, having received its first chunk; the turn's `call_kwargs` reach `acomplete`"
     body = turn.body
     reasoning = body.get('reasoning') or {}
     tools = list(body.get('tools') or []) + [dict(type='function', **get_schema(f, pname='parameters')) for f in turn.server_tools.values()]
@@ -188,7 +189,7 @@ async def call(self:AsyncResponses, turn):
     kwargs.update(tool_choice=body.get('tool_choice'), parallel_tool_calls=body.get('parallel_tool_calls', True),
         reasoning_effort=reasoning.get('effort'), max_tokens=body.get('max_output_tokens'), temperature=body.get('temperature'),
         cache_idxs=body.get('cache_idxs'), ttl=body.get('ttl'), web_search_options=body.get('web_search_options'))
-    stream = await acomplete(turn.provider_messages, model=body['model'], stream=True, **kwargs)
+    stream = await acomplete(turn.provider_messages, model=body['model'], stream=True, **kwargs, **turn.call_kwargs)
     first = await anext(stream)
     async def _rest():
         yield first
@@ -221,7 +222,7 @@ async def server_results(self:AsyncResponses, turn, comp):
 def server_turn(self:AsyncResponses, turn, comp, results):
     "The follow-up provider turn answering server tool `results`, within the same public response"
     outputs = [dict(type='function_call_output', call_id=r.id, output=r.text) for r in results]
-    nxt = self.prepare(turn.body | dict(input=outputs), self.state(turn, comp), turn.server_tools.values())
+    nxt = self.prepare(turn.body | dict(input=outputs), self.state(turn, comp), turn.server_tools.values(), **turn.call_kwargs)
     nxt.id = turn.id
     return nxt
 

{python_fastllm-0.0.47 → python_fastllm-0.0.48}/pyproject.toml

@@ -17,6 +17,9 @@ classifiers = [
 ]
 dependencies = ['fastcore>=2.1.18', 'aidialog>=0.0.10', 'fasttransport>=0.0.2', 'pillow']
 
+[project.scripts]
+fastllm-auth = "fastllm.codex:main"
+
 [project.urls]
 Repository = "https://github.com/AnswerDotAI/fastllm"
 

{python_fastllm-0.0.47 → python_fastllm-0.0.48}/python_fastllm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-fastllm
-Version: 0.0.47
+Version: 0.0.48
 Author-email: Kerem Turgutlu <keremturgutlu@gmail.com>
 License: Apache-2.0
 Project-URL: Repository, https://github.com/AnswerDotAI/fastllm

{python_fastllm-0.0.47 → python_fastllm-0.0.48}/python_fastllm.egg-info/entry_points.txt

@@ -1,3 +1,6 @@
+[console_scripts]
+fastllm-auth = fastllm.codex:main
+
 [fastaudit_import_allow]
 fastllm = fastllm
 

python_fastllm-0.0.47/fastllm/codex.py

@@ -1,7 +0,0 @@
-# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/05_codex.ipynb.
-
-# %% auto #0
-__all__ = []
-
-# %% ../nbs/05_codex.ipynb #a1d088d2
-from fastcore.utils import *