new config system, major

Author: iamlemec

oneping/__init__.py

@@ -1,4 +1,5 @@
-from .utils import cumcat, sprint, streamer, streamer_async
+from .utils import cumcat, sprint, streamer, streamer_async, load_image_uri
+from .providers import reload
 from .curl import (
     reply as reply_url,
     reply_async as reply_async_url,

oneping/api.py

@@ -1,6 +1,5 @@
 # combined interface
 
-from .providers import DEFAULT_PROVIDER
 from .native import has_native
 
 from .curl import (
@@ -21,43 +20,43 @@
     transcribe as transcribe_native,
 )
 
-def reply(query, provider=DEFAULT_PROVIDER, native=True, **kwargs):
+def reply(query, provider=None, native=True, **kwargs):
     if native and has_native(provider):
         return reply_native(query, provider, **kwargs)
     else:
         return reply_url(query, provider=provider, **kwargs)
 
-def reply_async(query, provider=DEFAULT_PROVIDER, native=True, **kwargs):
+def reply_async(query, provider=None, native=True, **kwargs):
     if native and has_native(provider):
         return reply_async_native(query, provider, **kwargs)
     else:
         return reply_async_url(query, provider=provider, **kwargs)
 
-def stream(query, provider=DEFAULT_PROVIDER, native=True, **kwargs):
+def stream(query, provider=None, native=True, **kwargs):
     if native and has_native(provider):
         return stream_native(query, provider, **kwargs)
     else:
         return stream_url(query, provider=provider, **kwargs)
 
-def stream_async(query, provider=DEFAULT_PROVIDER, native=True, **kwargs):
+def stream_async(query, provider=None, native=True, **kwargs):
     if native and has_native(provider):
         return stream_async_native(query, provider, **kwargs)
     else:
         return stream_async_url(query, provider=provider, **kwargs)
 
-def embed(text, provider=DEFAULT_PROVIDER, native=True, **kwargs):
+def embed(text, provider=None, native=True, **kwargs):
     if native and has_native(provider):
         return embed_native(text, provider, **kwargs)
     else:
         return embed_url(text, provider=provider, **kwargs)
 
-def tokenize(text, provider=DEFAULT_PROVIDER, native=True, **kwargs):
+def tokenize(text, provider=None, native=True, **kwargs):
     if native and has_native(provider):
         return tokenize_native(text, provider, **kwargs)
     else:
         return tokenize_url(text, provider=provider, **kwargs)
 
-def transcribe(audio, provider=DEFAULT_PROVIDER, native=True, **kwargs):
+def transcribe(audio, provider=None, native=True, **kwargs):
     if native and has_native(provider):
         return transcribe_native(audio, provider, **kwargs)
     else:

oneping/chat.py

@@ -1,6 +1,6 @@
 # chat interface
 
-from .providers import DEFAULT_SYSTEM, content_oneping
+from .providers import CONFIG as C, content_oneping
 from .api import reply, reply_async, stream, stream_async
 
 def history_update(query, text, image=None):
@@ -12,7 +12,7 @@ def history_update(query, text, image=None):
 # chat interface
 class Chat:
     def __init__(self, system=None, **kwargs):
-        self.system = DEFAULT_SYSTEM if system is None else system
+        self.system = C.system if system is None else system
         self.kwargs = kwargs
         self.clear()
 

oneping/config.toml

@@ -0,0 +1,2 @@
+# base config
+max_tokens = 8192

oneping/curl.py

@@ -5,7 +5,8 @@
 import requests
 import aiohttp
 
-from .providers import get_provider, convert_history, DEFAULT_MAX_TOKENS, DEFAULT_PROVIDER
+from .providers import get_provider, convert_history
+from .utils import ensure_image_uri
 
 ##
 ## printing
@@ -34,40 +35,44 @@ def prepare_model(prov, model_key, model=None):
     return {'model': model} if model is not None else {}
 
 def prepare_auth(prov, api_key=None):
-    if (auth_func := prov.get('authorize')) is not None:
-        if (api_key := os.environ.get(prov['api_key_env'])) is None:
-            raise Exception('Cannot find API key in {api_key_env}')
+    if (auth_func := prov.authorize) is not None:
+        if (api_key := os.environ.get(prov.api_key_env)) is None:
+            raise Exception(f'Cannot find API key in {prov.api_key_env}')
         headers_auth = auth_func(api_key)
     else:
         headers_auth = {}
     return headers_auth
 
 def prepare_request(
-    query, provider=DEFAULT_PROVIDER, system=None, image=None, prefill=None, prediction=None, history=None,
-    base_url=None, path=None, api_key=None, model=None, max_tokens=DEFAULT_MAX_TOKENS, **kwargs
+    query, provider=None, system=None, image=None, prefill=None, prediction=None, history=None,
+    base_url=None, path=None, api_key=None, model=None, max_tokens=None, **kwargs
 ):
     # external provider details
     prov = get_provider(provider)
-    max_tokens_name = prov.get('max_tokens_name', 'max_completion_tokens')
     url = prepare_url(prov, 'chat_path', base_url=base_url, path=path)
     payload_model = prepare_model(prov, 'chat_model', model=model)
 
     # convert history to provider format
-    history = convert_history(history, prov['content'])
+    history = convert_history(history, prov.content)
 
     # get extra headers
     headers_auth = prepare_auth(prov, api_key=api_key)
     headers_extra = prov.get('headers', {})
 
     # get message payload
-    content = prov['content'](query, image=image)
-    payload_message = prov['payload'](
+    img_data = ensure_image_uri(image)
+    content = prov.content(query, image=img_data)
+    payload_message = prov.payload(
         content, system=system, prefill=prefill, prediction=prediction, history=history
     )
 
     # compose request
     headers = {'Content-Type': 'application/json', **headers_auth, **headers_extra}
-    payload = {**payload_model, **payload_message, max_tokens_name: max_tokens, **kwargs}
+    payload = {**payload_model, **payload_message, **kwargs}
+
+    # add in max tokens
+    if max_tokens is not None:
+        payload[prov.max_tokens_name] = max_tokens
 
     # return url, headers, payload
     return url, headers, payload
@@ -76,10 +81,9 @@ def prepare_request(
 ## requests
 ##
 
-def reply(query, provider=DEFAULT_PROVIDER, history=None, prefill=None, dryrun=False, **kwargs):
+def reply(query, provider=None, history=None, prefill=None, dryrun=False, **kwargs):
     # get provider
     prov = get_provider(provider)
-    extractor = prov['response']
 
     # prepare request
     url, headers, payload = prepare_request(
@@ -97,7 +101,7 @@ def reply(query, provider=DEFAULT_PROVIDER, history=None, prefill=None, dryrun=F
 
     # extract text
     data = response.json()
-    text = extractor(data)
+    text = prov.response(data)
 
     # add in prefill
     if prefill is not None:
@@ -106,10 +110,9 @@ def reply(query, provider=DEFAULT_PROVIDER, history=None, prefill=None, dryrun=F
     # return text
     return text
 
-async def reply_async(query, provider=DEFAULT_PROVIDER, history=None, prefill=None, **kwargs):
+async def reply_async(query, provider=None, history=None, prefill=None, **kwargs):
     # get provider
     prov = get_provider(provider)
-    extractor = prov['response']
 
     # prepare request
     url, headers, payload = prepare_request(
@@ -123,7 +126,7 @@ async def reply_async(query, provider=DEFAULT_PROVIDER, history=None, prefill=No
 
             # extract text
             data = await response.json()
-            text = extractor(data)
+            text = prov.response(data)
 
     # add in prefill
     if prefill is not None:
@@ -154,10 +157,9 @@ async def iter_lines(inputs):
     if len(buffer) > 0:
         yield buffer
 
-def stream(query, provider=DEFAULT_PROVIDER, history=None, prefill=None, **kwargs):
+def stream(query, provider=None, history=None, prefill=None, **kwargs):
     # get provider
     prov = get_provider(provider)
-    extractor = prov['stream']
 
     # prepare request
     url, headers, payload = prepare_request(
@@ -181,14 +183,13 @@ def stream(query, provider=DEFAULT_PROVIDER, history=None, prefill=None, **kwarg
         for line in response.iter_lines():
             if (data := parse_sse(line)) is not None:
                 parsed = json.loads(data)
-                text = extractor(parsed)
+                text = prov.stream(parsed)
                 if text is not None:
                     yield text
 
-async def stream_async(query, provider=DEFAULT_PROVIDER, history=None, prefill=None, **kwargs):
+async def stream_async(query, provider=None, history=None, prefill=None, **kwargs):
     # get provider
     prov = get_provider(provider)
-    extractor = prov['stream']
 
     # prepare request
     url, headers, payload = prepare_request(
@@ -214,15 +215,15 @@ async def stream_async(query, provider=DEFAULT_PROVIDER, history=None, prefill=N
             async for line in iter_lines(chunks):
                 if (data := parse_sse(line)) is not None:
                     parsed = json.loads(data)
-                    text = extractor(parsed)
+                    text = prov.stream(parsed)
                     if text is not None:
                         yield text
 
 ##
 ## embeddings
 ##
 
-def embed(text, provider=DEFAULT_PROVIDER, base_url=None, path=None, api_key=None, model=None, timeout=None, **kwargs):
+def embed(text, provider=None, base_url=None, path=None, api_key=None, model=None, timeout=None, **kwargs):
     # get provider details
     prov = get_provider(provider)
     url = prepare_url(prov, f'embed_path', base_url=base_url, path=path)
@@ -233,7 +234,7 @@ def embed(text, provider=DEFAULT_PROVIDER, base_url=None, path=None, api_key=Non
 
     # make payload
     payload_model = prepare_model(prov, 'embed_model', model=model)
-    payload_message = prov['embed_payload'](text)
+    payload_message = prov.embed_payload(text)
 
     # compose request
     headers = {'Content-Type': 'application/json', **headers_auth, **headers_extra}
@@ -245,12 +246,12 @@ def embed(text, provider=DEFAULT_PROVIDER, base_url=None, path=None, api_key=Non
 
     # extract result
     data = response.json()
-    result = prov['embed_response'](data)
+    result = prov.embed_response(data)
 
     # return result
     return result
 
-def tokenize(text, provider=DEFAULT_PROVIDER, base_url=None, path=None, api_key=None, model=None, timeout=None, **kwargs):
+def tokenize(text, provider=None, base_url=None, path=None, api_key=None, model=None, timeout=None, **kwargs):
     # get provider details
     prov = get_provider(provider)
     url = prepare_url(prov, 'tokenize_path', base_url=base_url, path=path)
@@ -261,7 +262,7 @@ def tokenize(text, provider=DEFAULT_PROVIDER, base_url=None, path=None, api_key=
 
     # make payload
     payload_model = prepare_model(prov, 'embed_model', model=model)
-    payload_message = prov['tokenize_payload'](text)
+    payload_message = prov.tokenize_payload(text)
 
     # compose request
     headers = {'Content-Type': 'application/json', **headers_auth, **headers_extra}
@@ -273,7 +274,7 @@ def tokenize(text, provider=DEFAULT_PROVIDER, base_url=None, path=None, api_key=
 
     # extract result
     data = response.json()
-    result = prov['tokenize_response'](data)
+    result = prov.tokenize_response(data)
 
     # return result
     return result

oneping/native/__init__.py

@@ -5,7 +5,7 @@
 ##
 
 def has_native(provider):
-    return provider not in ('llama.cpp', 'tei', 'vllm', 'oneping')
+    return provider not in (None, 'llama.cpp', 'tei', 'vllm', 'oneping')
 
 ##
 ## dummy function

oneping/native/anthropic.py

@@ -4,7 +4,7 @@
 import anthropic
 
 from ..providers import (
-    DEFAULT_SYSTEM, DEFAULT_MAX_TOKENS, ANTHROPIC_MODEL, ANTHROPIC_HEADERS, ANTHROPIC_KEYENV,
+    CONFIG as C, PROVIDERS as P,
     content_anthropic, convert_history, payload_anthropic,
     response_anthropic_native, stream_anthropic_native
 )
@@ -22,35 +22,38 @@ def make_payload(query, image=None, system=None, history=None):
 ## common interface
 ##
 
-def make_client(api_key=None, headers=ANTHROPIC_HEADERS, async_client=False):
-    api_key = api_key if api_key is not None else os.environ.get(ANTHROPIC_KEYENV)
+def make_client(async_client=False, api_key=None):
+    api_key = api_key if api_key is not None else os.environ.get(P.anthropic.api_key_env)
     client_class = anthropic.AsyncAnthropic if async_client else anthropic.Anthropic
-    return client_class(api_key=api_key, default_headers=headers)
+    return client_class(api_key=api_key, default_headers=P.anthropic.headers)
 
-def reply(query, image=None, history=None, prefill=None, prediction=None, system=DEFAULT_SYSTEM, api_key=None, model=ANTHROPIC_MODEL, max_tokens=DEFAULT_MAX_TOKENS, headers=ANTHROPIC_HEADERS, **kwargs):
-    client = make_client(api_key=api_key, headers=headers)
+def reply(query, image=None, history=None, prefill=None, prediction=None, system=C.system, api_key=None, model=P.anthropic.chat_model, max_tokens=C.max_tokens, **kwargs):
+    client = make_client(api_key=api_key)
     payload = make_payload(query, image=image, system=system, history=history)
     response = client.messages.create(model=model, max_tokens=max_tokens, **payload, **kwargs)
     return response_anthropic_native(response)
 
-async def reply_async(query, image=None, history=None, prefill=None, prediction=None, system=DEFAULT_SYSTEM, api_key=None, model=ANTHROPIC_MODEL, max_tokens=DEFAULT_MAX_TOKENS, headers=ANTHROPIC_HEADERS, **kwargs):
-    client = make_client(api_key=api_key, headers=headers, async_client=True)
+async def reply_async(query, image=None, history=None, prefill=None, prediction=None, system=C.system, api_key=None, model=None, max_tokens=C.max_tokens, **kwargs):
+    model = model if model is not None else P.anthropic.chat_model
+    client = make_client(async_client=True, api_key=api_key)
     payload = make_payload(query, image=image, system=system, history=history)
     response = await client.messages.create(model=model, max_tokens=max_tokens, **payload, **kwargs)
     text = response_anthropic_native(response)
     return (prefill + text) if prefill is not None else text
 
-def stream(query, image=None, history=None, prefill=None, prediction=None, system=DEFAULT_SYSTEM, api_key=None, model=ANTHROPIC_MODEL, max_tokens=DEFAULT_MAX_TOKENS, headers=ANTHROPIC_HEADERS, **kwargs):
-    client = make_client(api_key=api_key, headers=headers)
+def stream(query, image=None, history=None, prefill=None, prediction=None, system=C.system, api_key=None, model=None, max_tokens=C.max_tokens, **kwargs):
+    model = model if model is not None else P.anthropic.chat_model
+    client = make_client(api_key=api_key)
     payload = make_payload(query, image=image, system=system, history=history)
     response = client.messages.create(model=model, stream=True, max_tokens=max_tokens, **payload, **kwargs)
     if prefill is not None:
         yield prefill
     for chunk in response:
         yield stream_anthropic_native(chunk)
 
-async def stream_async(query, image=None, history=None, prefill=None, prediction=None, system=DEFAULT_SYSTEM, api_key=None, model=ANTHROPIC_MODEL, max_tokens=DEFAULT_MAX_TOKENS, headers=ANTHROPIC_HEADERS, **kwargs):
-    client = make_client(api_key=api_key, headers=headers, async_client=True)
+async def stream_async(query, image=None, history=None, prefill=None, prediction=None, system=C.system, api_key=None, model=None, max_tokens=C.max_tokens, **kwargs):
+    model = model if model is not None else P.anthropic.chat_model
+    client = make_client(async_client=True, api_key=api_key)
     payload = make_payload(query, image=image, system=system, history=history)
     response = await client.messages.create(model=model, stream=True, max_tokens=max_tokens, **payload, **kwargs)
     if prefill is not None: