beamlit 0.0.20rc4__tar.gz → 0.0.20rc5__tar.gz

{beamlit-0.0.20rc4 → beamlit-0.0.20rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: beamlit
-Version: 0.0.20rc4
+Version: 0.0.20rc5
 Summary: Add your description here
 Author-email: cploujoux <ch.ploujoux@gmail.com>
 Requires-Python: >=3.12

{beamlit-0.0.20rc4 → beamlit-0.0.20rc5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beamlit"
-version = "0.0.20.pre-4"
+version = "0.0.20.pre-5"
 description = "Add your description here"
 readme = "README.md"
 authors = [

{beamlit-0.0.20rc4 → beamlit-0.0.20rc5}/src/beamlit/authentication/__init__.py

@@ -1,5 +1,7 @@
 from .apikey import ApiKeyProvider
 from .authentication import (PublicProvider, RunClientWithCredentials,
+                             get_authentication_headers,
+                             new_client_from_settings,
                              new_client_with_credentials)
 from .credentials import (Config, ContextConfig, Credentials, WorkspaceConfig,
                           load_credentials, load_credentials_from_settings)
@@ -11,6 +13,8 @@ __all__ = (
     "PublicProvider",
     "RunClientWithCredentials",
     "new_client_with_credentials",
+    "new_client_from_settings",
+    "get_authentication_headers",
     "Config",
     "ContextConfig",
     "Credentials",

{beamlit-0.0.20rc4 → beamlit-0.0.20rc5}/src/beamlit/authentication/apikey.py

@@ -8,6 +8,12 @@ class ApiKeyProvider(Auth):
         self.credentials = credentials
         self.workspace_name = workspace_name
 
+    def get_headers(self):
+        return {
+            'X-Beamlit-Api-Key': self.credentials.api_key,
+            'X-Beamlit-Workspace': self.workspace_name
+        }
+
     def auth_flow(self, request: Request) -> Generator[Request, Response, None]:
         request.headers['X-Beamlit-Api-Key'] = self.credentials.api_key
         request.headers['X-Beamlit-Workspace'] = self.workspace_name

beamlit-0.0.20rc5/src/beamlit/authentication/authentication.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass
+from typing import Dict, Generator
+
+from beamlit.common.settings import Settings
+from httpx import Auth, Request, Response
+
+from ..client import AuthenticatedClient
+from .apikey import ApiKeyProvider
+from .clientcredentials import ClientCredentials
+from .credentials import Credentials, load_credentials_from_settings
+from .device_mode import BearerToken
+
+
+class PublicProvider(Auth):
+    def auth_flow(self, request: Request) -> Generator[Request, Response, None]:
+        yield request
+
+
+
+@dataclass
+class RunClientWithCredentials:
+    credentials: Credentials
+    workspace: str
+    api_url: str = "https://api.beamlit.dev/v0"
+    run_url: str = "https://run.beamlit.dev/v0"
+
+
+def new_client_from_settings(settings: Settings):
+    credentials = load_credentials_from_settings(settings)
+
+    client_config = RunClientWithCredentials(
+        credentials=credentials,
+        workspace=settings.workspace,
+    )
+    return new_client_with_credentials(client_config)
+
+def new_client_with_credentials(config: RunClientWithCredentials):
+    provider: Auth = None
+    if config.credentials.api_key:
+        provider = ApiKeyProvider(config.credentials, config.workspace)
+    elif config.credentials.access_token:
+        provider = BearerToken(config.credentials, config.workspace, config.api_url)
+    elif config.credentials.client_credentials:
+        provider = ClientCredentials(config.credentials, config.workspace, config.api_url)
+    else:
+        provider = PublicProvider()
+
+    return AuthenticatedClient(base_url=config.api_url, provider=provider)
+
+def get_authentication_headers(settings: Settings) -> Dict[str, str]:
+    credentials = load_credentials_from_settings(settings)
+    config = RunClientWithCredentials(
+        credentials=credentials,
+        workspace=settings.workspace,
+    )
+    provider = None
+    if config.credentials.api_key:
+        provider = ApiKeyProvider(config.credentials, config.workspace)
+    elif config.credentials.access_token:
+        provider = BearerToken(config.credentials, config.workspace, config.api_url)
+    elif config.credentials.client_credentials:
+        provider = ClientCredentials(config.credentials, config.workspace, config.api_url)
+
+    if provider is None:
+        return None
+
+    return provider.get_headers()

{beamlit-0.0.20rc4 → beamlit-0.0.20rc5}/src/beamlit/authentication/clientcredentials.py

@@ -23,7 +23,27 @@ class ClientCredentials(Auth):
         self.workspace_name = workspace_name
         self.base_url = base_url
 
+    def get_headers(self):
+        err = self.refresh_if_needed()
+        if err:
+            raise err
+
+        return {
+            'X-Beamlit-Authorization': f'Bearer {self.credentials.access_token}',
+            'X-Beamlit-Workspace': self.workspace_name
+        }
+
     def refresh_if_needed(self) -> Optional[Exception]:
+        settings = get_settings()
+        if self.credentials.client_credentials and not self.credentials.refresh_token:
+            headers = { "Authorization": f"Basic {self.credentials.client_credentials}" }
+            body = { "grant_type": "client_credentials" }
+            response = requests.post(f"{settings.base_url}/oauth/token", headers=headers, json=body)
+            response.raise_for_status()
+            self.credentials.access_token = response.json()['access_token']
+            self.credentials.refresh_token = response.json()['refresh_token']
+            self.credentials.expires_in = response.json()['expires_in']
+
         # Need to refresh token if expires in less than 10 minutes
         parts = self.credentials.access_token.split('.')
         if len(parts) != 3:
@@ -42,15 +62,6 @@ class ClientCredentials(Auth):
         return None
 
     def auth_flow(self, request: Request) -> Generator[Request, Response, None]:
-        settings = get_settings()
-        if self.credentials.client_credentials and not self.credentials.refresh_token:
-            headers = { "Authorization": f"Basic {self.credentials.client_credentials}" }
-            body = { "grant_type": "client_credentials" }
-            response = requests.post(f"{settings.base_url}/oauth/token", headers=headers, json=body)
-            response.raise_for_status()
-            self.credentials.access_token = response.json()['access_token']
-            self.credentials.refresh_token = response.json()['refresh_token']
-            self.credentials.expires_in = response.json()['expires_in']
         err = self.refresh_if_needed()
         if err:
             return err

{beamlit-0.0.20rc4 → beamlit-0.0.20rc5}/src/beamlit/authentication/credentials.py

@@ -14,6 +14,7 @@ class Credentials:
     expires_in: int = 0
     device_code: str = ""
     client_credentials: str = ""
+
 @dataclass
 class WorkspaceConfig:
     name: str

{beamlit-0.0.20rc4 → beamlit-0.0.20rc5}/src/beamlit/authentication/device_mode.py

@@ -2,7 +2,7 @@ import base64
 import json
 import time
 from dataclasses import dataclass
-from typing import Generator, Optional
+from typing import Dict, Generator, Optional
 
 from httpx import Auth, Request, Response, post
 
@@ -45,6 +45,15 @@ class BearerToken(Auth):
         self.workspace_name = workspace_name
         self.base_url = base_url
 
+    def get_headers(self) -> Dict[str, str]:
+        err = self.refresh_if_needed()
+        if err:
+            raise err
+        return {
+            'X-Beamlit-Authorization': f'Bearer {self.credentials.access_token}',
+            'X-Beamlit-Workspace': self.workspace_name
+        }
+
     def refresh_if_needed(self) -> Optional[Exception]:
         # Need to refresh token if expires in less than 10 minutes
         parts = self.credentials.access_token.split('.')

{beamlit-0.0.20rc4 → beamlit-0.0.20rc5}/src/beamlit/common/logger.py

@@ -19,6 +19,8 @@ class ColoredFormatter(logging.Formatter):
 def init(log_level: str):
     logging.getLogger("uvicorn.access").handlers.clear()
     logging.getLogger("uvicorn.access").propagate = False
+    logging.getLogger("uvicorn.error").handlers.clear()
+    logging.getLogger("uvicorn.error").propagate = False
     logging.getLogger("httpx").handlers.clear()
     logging.getLogger("httpx").propagate = False
 

{beamlit-0.0.20rc4 → beamlit-0.0.20rc5}/src/main.py

@@ -1,22 +1,15 @@
 from typing import List
 
 from beamlit.api.models import get_model_deployment
-from beamlit.authentication import (RunClientWithCredentials,
-                                    load_credentials_from_settings,
-                                    new_client_with_credentials)
+from beamlit.authentication import (get_authentication_headers,
+                                    new_client_from_settings)
 from beamlit.common.settings import init, init_agent
 from beamlit.models.model import Model
 from beamlit.models.model_deployment import ModelDeployment
 from beamlit.run import RunClient
 
 settings = init()
-credentials = load_credentials_from_settings(settings)
-
-client_config = RunClientWithCredentials(
-    credentials=credentials,
-    workspace=settings.workspace,
-)
-client = new_client_with_credentials(client_config)
+client = new_client_from_settings(settings)
 model_deployment: ModelDeployment = get_model_deployment.sync("all-minilm-l6-v2", "production", client=client)
 init_agent(client=client)
 run_client = RunClient(client=client)
@@ -27,5 +20,5 @@ response = run_client.run(
     method="POST",
     json={"query": "4+4"}
 )
-
-print(response.json())
+print(response.json())
+print(get_authentication_headers(settings))

beamlit-0.0.20rc4/src/beamlit/authentication/authentication.py

@@ -1,38 +0,0 @@
-from dataclasses import dataclass
-from typing import Generator
-
-from httpx import Auth, Request, Response
-
-from ..client import AuthenticatedClient
-from .apikey import ApiKeyProvider
-from .clientcredentials import ClientCredentials
-from .credentials import Credentials
-from .device_mode import BearerToken
-
-
-class PublicProvider(Auth):
-    def auth_flow(self, request: Request) -> Generator[Request, Response, None]:
-        yield request
-
-
-
-@dataclass
-class RunClientWithCredentials:
-    credentials: Credentials
-    workspace: str
-    api_url: str = "https://api.beamlit.dev/v0"
-    run_url: str = "https://run.beamlit.dev/v0"
-
-
-def new_client_with_credentials(config: RunClientWithCredentials):
-    provider: Auth = None
-    if config.credentials.api_key:
-        provider = ApiKeyProvider(config.credentials, config.workspace)
-    elif config.credentials.access_token:
-        provider = BearerToken(config.credentials, config.workspace, config.api_url)
-    elif config.credentials.client_credentials:
-        provider = ClientCredentials(config.credentials, config.workspace, config.api_url)
-    else:
-        provider = PublicProvider()
-
-    return AuthenticatedClient(base_url=config.api_url, provider=provider)