kalavai-client 0.6.13__py3-none-any.whl → 0.6.14__py3-none-any.whl

kalavai_client/__init__.py

@@ -1,2 +1,2 @@
 
-__version__ = "0.6.13"
+__version__ = "0.6.14"

kalavai_client/assets/apps.yaml

@@ -152,7 +152,7 @@ releases:
     - name: replicas
       value: 1
     - name: image_tag
-      value: "v2025.05.2"
+      value: "v2025.06.6"
     - name: deployment.in_cluster
       value: "True"
     - name: deployment.kalavai_username_key

kalavai_client/assets/docker-compose-template.yaml

@@ -18,6 +18,7 @@ services:
 {%if command %}
   {{service_name}}:
     image: docker.io/bundenth/kalavai-runner:gpu-latest
+    pull_policy: always
     container_name: {{service_name}}
   {% if vpn %}
     depends_on:
@@ -35,6 +36,9 @@ services:
     {% endif %}
       --node_name="{{node_name}}"
       --node_ip="{{node_ip_address}}"
+    {% if random_suffix %}
+      --random_suffix="{{random_suffix}}"
+    {% endif %}
       {% if command == "server" %}
       --port_range="30000-32767"
       {% else %}

kalavai_client/bridge_api.py

@@ -54,12 +54,22 @@ from kalavai_client.core import (
 )
 from kalavai_client.utils import load_user_id
 
-app = FastAPI()
+app = FastAPI(
+    title="Kalavai Bridge API",
+    description="API for managing Kalavai pools, jobs, and nodes",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
 
 ################################
 ## API Key Validation methods ##
 ################################
 async def verify_api_key(request: Request):
+    """
+    Verify the API key from the request headers.
+    The API key must match the user ID.
+    """
     user_id = load_user_id()
     if user_id is None:
         return None
@@ -68,8 +78,25 @@ async def verify_api_key(request: Request):
         raise HTTPException(status_code=401, detail="Request requires API Key")
     return api_key
 
-@app.post("/create_pool")
+@app.post("/create_pool", 
+    summary="Create a new pool",
+    description="Creates a new pool with the specified configuration",
+    response_description="Result of pool creation")
 def pool_create(request: CreatePoolRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Create a new pool with the following parameters:
+    
+    - **cluster_name**: Name of the cluster
+    - **ip_address**: IP address for the pool
+    - **app_values**: Application configuration values
+    - **num_gpus**: Number of GPUs to allocate
+    - **node_name**: Name of the node
+    - **only_registered_users**: Whether to restrict to registered users
+    - **location**: Location of the pool
+    - **description**: Pool description
+    - **token_mode**: Token type for authentication
+    - **frontend**: Whether this is a frontend request
+    """
     result = create_pool(
         cluster_name=request.cluster_name,
         ip_address=request.ip_address,
@@ -84,8 +111,20 @@ def pool_create(request: CreatePoolRequest, api_key: str = Depends(verify_api_ke
     )
     return result
 
-@app.post("/join_pool")
+@app.post("/join_pool",
+    summary="Join an existing pool",
+    description="Join a pool using a token",
+    response_description="Result of joining the pool")
 def pool_join(request: JoinPoolRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Join a pool with the following parameters:
+    
+    - **token**: Pool join token
+    - **ip_address**: IP address for the node
+    - **node_name**: Name of the node
+    - **num_gpus**: Number of GPUs to allocate
+    - **frontend**: Whether this is a frontend request
+    """
     result = join_pool(
         token=request.token,
         num_gpus=request.num_gpus,
@@ -95,8 +134,18 @@ def pool_join(request: JoinPoolRequest, api_key: str = Depends(verify_api_key)):
     )
     return result
 
-@app.post("/attach_to_pool")
+@app.post("/attach_to_pool",
+    summary="Attach to an existing pool",
+    description="Attach to a pool using a token",
+    response_description="Result of attaching to the pool")
 def pool_attach(request: JoinPoolRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Attach to a pool with the following parameters:
+    
+    - **token**: Pool token
+    - **node_name**: Name of the node
+    - **frontend**: Whether this is a frontend request
+    """
     result = attach_to_pool(
         token=request.token,
         node_name=request.node_name,
@@ -104,65 +153,157 @@ def pool_attach(request: JoinPoolRequest, api_key: str = Depends(verify_api_key)
     )
     return result
 
-@app.post("/stop_pool")
+@app.post("/stop_pool",
+    summary="Stop a pool",
+    description="Stop the current pool",
+    response_description="Result of stopping the pool")
 def pool_stop(request: StopPoolRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Stop the pool with the following parameters:
+    
+    - **skip_node_deletion**: Whether to skip node deletion
+    """
     result = stop_pool(
         skip_node_deletion=request.skip_node_deletion
     )
     return result
 
-@app.post("/delete_nodes")
+@app.post("/delete_nodes",
+    summary="Delete nodes",
+    description="Delete specified nodes from the pool",
+    response_description="Result of node deletion")
 def device_delete(request: NodesActionRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Delete nodes with the following parameters:
+    
+    - **nodes**: List of node names to delete
+    """
     result = delete_nodes(
         nodes=request.nodes
     )
     return result
 
-@app.post("/cordon_nodes")
+@app.post("/cordon_nodes",
+    summary="Cordon nodes",
+    description="Mark nodes as unschedulable",
+    response_description="Result of cordoning nodes")
 def device_cordon(request: NodesActionRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Cordon nodes with the following parameters:
+    
+    - **nodes**: List of node names to cordon
+    """
     result = cordon_nodes(
         nodes=request.nodes
     )
     return result
 
-@app.post("/uncordon_nodes")
+@app.post("/uncordon_nodes",
+    summary="Uncordon nodes",
+    description="Mark nodes as schedulable",
+    response_description="Result of uncordoning nodes")
 def device_uncordon(request: NodesActionRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Uncordon nodes with the following parameters:
+    
+    - **nodes**: List of node names to uncordon
+    """
     result = uncordon_nodes(
         nodes=request.nodes
     )
     return result
 
-@app.get("/get_pool_token")
+@app.get("/get_pool_token",
+    summary="Get pool token",
+    description="Get a token for the pool",
+    response_description="Pool token")
 def get_token(mode: int, api_key: str = Depends(verify_api_key)):
-
+    """
+    Get pool token with the following parameters:
+    
+    - **mode**: Token type mode
+    """
     return get_pool_token(mode=TokenType(mode))
 
-@app.get("/fetch_devices")
+@app.get("/fetch_devices",
+    summary="Fetch devices",
+    description="Get list of available devices",
+    response_description="List of devices")
 def get_devices(api_key: str = Depends(verify_api_key)):
+    """Get list of available devices"""
     return fetch_devices()
 
-@app.post("/send_pool_invites")
+@app.post("/send_pool_invites",
+    summary="Send pool invites",
+    description="Send invites to join the pool",
+    response_description="Result of sending invites")
 def send_pool_invites(request: InvitesRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Send pool invites with the following parameters:
+    
+    - **invitees**: List of invitee identifiers
+    """
     return send_invites(invitees=request.invitees)
 
-@app.get("/fetch_resources")
+@app.get("/fetch_resources",
+    summary="Fetch resources",
+    description="Get available resources",
+    response_description="Resource information")
 def resources(api_key: str = Depends(verify_api_key)):
+    """Get available resources"""
     return fetch_resources()
 
-@app.get("/fetch_job_names")
+@app.get("/fetch_job_names",
+    summary="Fetch job names",
+    description="Get list of job names",
+    response_description="List of job names")
 def job_names(api_key: str = Depends(verify_api_key)):
+    """Get list of job names"""
     return fetch_job_names()
 
-@app.get("/fetch_gpus")
+@app.get("/fetch_gpus",
+    summary="Fetch GPUs",
+    description="Get list of available GPUs",
+    response_description="List of GPUs")
 def gpus(available: bool = False, api_key: str = Depends(verify_api_key)):
+    """
+    Get list of GPUs with the following parameters:
+    
+    - **available**: Whether to show only available GPUs
+    """
     return fetch_gpus(available=available)
 
-@app.post("/fetch_job_details")
+@app.post("/fetch_job_details",
+    summary="Fetch job details",
+    description="Get details for specified jobs",
+    response_description="Job details")
 def job_details(request: JobDetailsRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Get job details with the following parameters:
+    
+    - **jobs**: List of jobs to get details for
+    """
     return fetch_job_details(jobs=request.jobs)
 
-@app.get("/fetch_job_logs")
-def job_logs(job_name: str, force_namespace: str=None, pod_name: str=None, tail: int=100, api_key: str = Depends(verify_api_key)):
+@app.get("/fetch_job_logs",
+    summary="Fetch job logs",
+    description="Get logs for a specific job",
+    response_description="Job logs")
+def job_logs(
+    job_name: str,
+    force_namespace: str = None,
+    pod_name: str = None,
+    tail: int = 100,
+    api_key: str = Depends(verify_api_key)
+):
+    """
+    Get job logs with the following parameters:
+    
+    - **job_name**: Name of the job
+    - **force_namespace**: Optional namespace override
+    - **pod_name**: Optional pod name
+    - **tail**: Number of log lines to return
+    """
     return fetch_job_logs(
         job_name=job_name,
         force_namespace=force_namespace,
@@ -170,16 +311,39 @@ def job_logs(job_name: str, force_namespace: str=None, pod_name: str=None, tail:
         tail=tail
     )
 
-@app.get("/fetch_job_templates")
+@app.get("/fetch_job_templates",
+    summary="Fetch job templates",
+    description="Get available job templates",
+    response_description="List of job templates")
 def job_templates(api_key: str = Depends(verify_api_key)):
+    """Get available job templates"""
     return fetch_job_templates()
 
-@app.get("/fetch_job_defaults")
+@app.get("/fetch_job_defaults",
+    summary="Fetch job defaults",
+    description="Get default values for a job template",
+    response_description="Job default values")
 def job_templates(name: str, api_key: str = Depends(verify_api_key)):
+    """
+    Get job defaults with the following parameters:
+    
+    - **name**: Name of the job template
+    """
     return fetch_job_defaults(name=name)
 
-@app.post("/deploy_job")
+@app.post("/deploy_job",
+    summary="Deploy job",
+    description="Deploy a new job",
+    response_description="Result of job deployment")
 def job_deploy(request: DeployJobRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Deploy a job with the following parameters:
+    
+    - **template_name**: Name of the job template
+    - **values**: Job configuration values
+    - **force_namespace**: Optional namespace override
+    - **target_labels**: Optional target node labels
+    """
     result = deploy_job(
         template_name=request.template_name,
         values_dict=request.values,
@@ -188,76 +352,154 @@ def job_deploy(request: DeployJobRequest, api_key: str = Depends(verify_api_key)
     )
     return result
 
-@app.post("/delete_job")
+@app.post("/delete_job",
+    summary="Delete job",
+    description="Delete a job",
+    response_description="Result of job deletion")
 def job_delete(request: DeleteJobRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Delete a job with the following parameters:
+    
+    - **name**: Name of the job to delete
+    - **force_namespace**: Optional namespace override
+    """
     result = delete_job(
         name=request.name,
         force_namespace=request.force_namespace
     )
     return result
 
-@app.get("/authenticate_user")
+@app.get("/authenticate_user",
+    summary="Authenticate user",
+    description="Authenticate a user",
+    response_description="Authentication result")
 def user_authenticate(user_id: str, api_key: str = Depends(verify_api_key)):
+    """
+    Authenticate user with the following parameters:
+    
+    - **user_id**: User identifier
+    """
     result = authenticate_user(
         user_id=user_id
     )
     return result
 
-@app.get("/load_user_session")
+@app.get("/load_user_session",
+    summary="Load user session",
+    description="Load the current user session",
+    response_description="User session information")
 def user_session(api_key: str = Depends(verify_api_key)):
+    """Load the current user session"""
     result = load_user_session()
     return result
 
-@app.get("/user_logout")
+@app.get("/user_logout",
+    summary="User logout",
+    description="Log out the current user",
+    response_description="Logout result")
 def logout_user():
+    """Log out the current user"""
     result = user_logout()
     return result
 
-@app.get("/is_connected")
+@app.get("/is_connected",
+    summary="Check connection",
+    description="Check if connected to a pool",
+    response_description="Connection status")
 def pool_connected():
+    """Check if connected to a pool"""
     result = is_connected()
     return result
 
-@app.get("/is_agent_running")
+@app.get("/is_agent_running",
+    summary="Check agent status",
+    description="Check if the agent is running",
+    response_description="Agent status")
 def agent_running():
+    """Check if the agent is running"""
     result = is_agent_running()
     return result
 
-@app.get("/is_server")
+@app.get("/is_server",
+    summary="Check server status",
+    description="Check if running as server",
+    response_description="Server status")
 def server():
+    """Check if running as server"""
     result = is_server()
     return result
 
-@app.post("/pause_agent")
+@app.post("/pause_agent",
+    summary="Pause agent",
+    description="Pause the agent",
+    response_description="Result of pausing agent")
 def agent_pause():
+    """Pause the agent"""
     result = pause_agent()
     return result
 
-@app.post("/resume_agent")
+@app.post("/resume_agent",
+    summary="Resume agent",
+    description="Resume the agent",
+    response_description="Result of resuming agent")
 def agent_resume():
+    """Resume the agent"""
     result = resume_agent()
     return result
 
-@app.get("/get_ip_addresses")
-def ip_addresses(subnet: str=None, api_key: str = Depends(verify_api_key)):
+@app.get("/get_ip_addresses",
+    summary="Get IP addresses",
+    description="Get available IP addresses",
+    response_description="List of IP addresses")
+def ip_addresses(subnet: str = None, api_key: str = Depends(verify_api_key)):
+    """
+    Get IP addresses with the following parameters:
+    
+    - **subnet**: Optional subnet to filter by
+    """
     result = get_ip_addresses(subnet=subnet)
     return result
 
-@app.get("/list_available_pools")
-def pool_connected(user_only: bool=False, api_key: str = Depends(verify_api_key)):
+@app.get("/list_available_pools",
+    summary="List available pools",
+    description="Get list of available pools",
+    response_description="List of available pools")
+def pool_connected(user_only: bool = False, api_key: str = Depends(verify_api_key)):
+    """
+    List available pools with the following parameters:
+    
+    - **user_only**: Whether to show only user's pools
+    """
     result = list_available_pools(user_only=user_only)
     return result
 
-@app.post("/add_node_labels")
+@app.post("/add_node_labels",
+    summary="Add node labels",
+    description="Add labels to a node",
+    response_description="Result of adding labels")
 def node_labels(request: NodeLabelsRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Add node labels with the following parameters:
+    
+    - **node_name**: Name of the node
+    - **labels**: Dictionary of labels to add
+    """
     result = add_node_labels(
         node_name=request.node_name,
         labels=request.labels
     )
     return result
 
-@app.post("/get_node_labels")
+@app.post("/get_node_labels",
+    summary="Get node labels",
+    description="Get labels for specified nodes",
+    response_description="Node labels")
 def node_labels_get(request: GetNodeLabelsRequest, api_key: str = Depends(verify_api_key)):
+    """
+    Get node labels with the following parameters:
+    
+    - **node_names**: List of node names to get labels for
+    """
     result = get_node_labels(
         node_names=request.node_names
     )

kalavai_client/bridge_models.py

@@ -1,53 +1,53 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from typing import List, Dict, Optional
 
 from kalavai_client.core import Job, TokenType
 
 
 class InvitesRequest(BaseModel):
-    invitees: list[str]
+    invitees: list[str] = Field(description="List of user identifiers to invite to the pool")
 
 class CreatePoolRequest(BaseModel):
-    cluster_name: str
-    ip_address: str
-    app_values: dict = None
-    num_gpus: int = None
-    node_name: str = None
-    only_registered_users: bool = False
-    location: str = None
-    token_mode: TokenType = TokenType.USER
-    description: str = ""
-    frontend: bool = False
+    cluster_name: str = Field(description="Name of the cluster to create")
+    ip_address: str = Field(description="IP address for the pool")
+    app_values: dict = Field(None, description="Application configuration values")
+    num_gpus: int = Field(None, description="Number of GPUs to allocate")
+    node_name: str = Field(None, description="Name of the node")
+    only_registered_users: bool = Field(False, description="Whether to restrict access to registered users only")
+    location: str = Field(None, description="Geographic location of the pool")
+    token_mode: TokenType = Field(TokenType.USER, description="Token type for authentication")
+    description: str = Field("", description="Description of the pool")
+    frontend: bool = Field(False, description="Whether this is a frontend request")
 
 class NodesActionRequest(BaseModel):
-    nodes: list[str]
+    nodes: list[str] = Field(description="List of node names to perform the action on")
 
 class JoinPoolRequest(BaseModel):
-    token: str
-    ip_address: str = None
-    node_name: str = None
-    num_gpus: int = None
-    frontend: bool = False
+    token: str = Field(description="Token to join the pool")
+    ip_address: str = Field(None, description="IP address for the node")
+    node_name: str = Field(None, description="Name of the node")
+    num_gpus: int = Field(None, description="Number of GPUs to allocate")
+    frontend: bool = Field(False, description="Whether this is a frontend request")
 class JobDetailsRequest(BaseModel):
-    jobs: list[Job]
+    jobs: list[Job] = Field(description="List of jobs to get details for")
 
 
 class StopPoolRequest(BaseModel):
-    skip_node_deletion: bool = False
+    skip_node_deletion: bool = Field(False, description="Whether to skip node deletion when stopping the pool")
 
 class DeployJobRequest(BaseModel):
-    template_name: str
-    values: dict
-    force_namespace: str = None
-    target_labels: dict[str, str] = None
+    template_name: str = Field(description="Name of the job template to use")
+    values: dict = Field(description="Job configuration values")
+    force_namespace: str = Field(None, description="Optional namespace override")
+    target_labels: dict[str, str] = Field(None, description="Optional target node labels")
 
 class DeleteJobRequest(BaseModel):
-    name: str
-    force_namespace: str = None
+    name: str = Field(description="Name of the job to delete")
+    force_namespace: str = Field(None, description="Optional namespace override")
 
 class NodeLabelsRequest(BaseModel):
-    node_name: str
-    labels: Dict[str, str]
+    node_name: str = Field(description="Name of the node to add labels to")
+    labels: Dict[str, str] = Field(description="Dictionary of labels to add to the node")
 
 class GetNodeLabelsRequest(BaseModel):
-    node_names: List[str]
+    node_names: List[str] = Field(description="List of node names to get labels for")

kalavai_client/utils.py

@@ -126,6 +126,7 @@ def generate_compose_config(role, node_name, write_to_file=True, node_ip_address
         "num_gpus": num_gpus,
         "k3s_path": f"{CONTAINER_HOST_PATH}/{rand_suffix}/k3s",
         "etc_path": f"{CONTAINER_HOST_PATH}/{rand_suffix}/etc",
+        "random_suffix": rand_suffix,
         "node_labels": node_labels,
         "flannel_iface": DEFAULT_FLANNEL_IFACE if vpn_token is not None else "",
         "user_id": load_user_id()

{kalavai_client-0.6.13.dist-info → kalavai_client-0.6.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: kalavai-client
-Version: 0.6.13
+Version: 0.6.14
 Summary: Client app for kalavai platform
 License: Apache-2.0
 Keywords: LLM,platform

{kalavai_client-0.6.13.dist-info → kalavai_client-0.6.14.dist-info}/RECORD

@@ -1,25 +1,25 @@
-kalavai_client/__init__.py,sha256=RtAfZnVOn5ru1jOt5ukVyb0s2GiJ7s39Qp5_KBjCL-A,23
+kalavai_client/__init__.py,sha256=nfdFjB1S39Wxvq7GI6NuNOdisKxExyZQSWX0Q2sAupU,23
 kalavai_client/__main__.py,sha256=WQUfxvRsBJH5gsCJg8pLz95QnZIj7Ol8psTO77m0QE0,73
 kalavai_client/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kalavai_client/assets/apps.yaml,sha256=AhTA3VZI27y05xHoHJCA9nvGnk8sWMhFDruBI2is3LM,6365
+kalavai_client/assets/apps.yaml,sha256=L0hi826JwWW0rDRD83wcFVJVNZoUnafPdsjpharBrHE,6365
 kalavai_client/assets/apps_values.yaml,sha256=WRew3bS1MztjzcJfphuJcKn0n2T1ICRupPpr_Csjt_s,1644
 kalavai_client/assets/docker-compose-gui.yaml,sha256=DGCyGYzz1kH6kkMbo62FJHe3F9vcAmA8DOHw-c_o0Kw,752
-kalavai_client/assets/docker-compose-template.yaml,sha256=Nz_JzeBnQCzPCyWP5cEQHFeZzPwQqqBJ3C_xrToWlMA,1654
+kalavai_client/assets/docker-compose-template.yaml,sha256=w9Eux2-lQgkGFbNhwHwurlRJe13CVZPrAGOiFBfI5I0,1763
 kalavai_client/assets/nginx.conf,sha256=drVVCg8GHucz7hmt_BI6giAhK92OV71257NTs3LthwM,225
 kalavai_client/assets/pool_config_template.yaml,sha256=fFz4w2-fMKD5KvyzFdfcWD_jSneRlmnjLc8hCctweX0,576
 kalavai_client/assets/pool_config_values.yaml,sha256=VrM3XHQfQo6QLZ68qvagooUptaYgl1pszniY_JUtemk,233
 kalavai_client/assets/user_workspace.yaml,sha256=wDvlMYknOPABAEo0dsQwU7bac8iubjAG9tdkFbJZ5Go,476
 kalavai_client/assets/user_workspace_values.yaml,sha256=G0HOzQUxrDMCwuW9kbWUZaKMzDDPVwDwzBHCL2Xi2ZM,542
 kalavai_client/auth.py,sha256=EB3PMvKUn5_KAQkezkEHEt-OMZXyfkZguIQlUFkEHcA,3243
-kalavai_client/bridge_api.py,sha256=ZLyFOOz_o4agm-7DrHzoSBFrH65y__hZUoEe4diBTOA,7557
-kalavai_client/bridge_models.py,sha256=GbIaqGFAVs-3ikVUQZldwTTc06SsxmP6iAifH0oVDro,1219
+kalavai_client/bridge_api.py,sha256=-z0NBUSRJkVOfP807Fd-ZX2uEtKc6BCfrDD_umQ6sNg,15592
+kalavai_client/bridge_models.py,sha256=775aXLTma3dv6KmKTmebAZ55ns6d9EmNno5e4blfoNY,2738
 kalavai_client/cli.py,sha256=mmwLqqSYfl9k6vqveMcbHTq7g5FFd84YUUQCSH4J0k0,46967
 kalavai_client/cluster.py,sha256=Z2PIXbZuSAv9xmw-MyZP1M41BpVMpirLzG51bqGA-zc,13548
 kalavai_client/core.py,sha256=u8a4uYqGS0mMJh0ArcXG2hwp2uDUSuwM5ROGXRQkHZg,34051
 kalavai_client/env.py,sha256=YsfZj7LWf6ABquDsoIFFkXCFYwenpDk8zVnGsf7qv98,2823
-kalavai_client/utils.py,sha256=yHz9n4hGwhpGUTc1ZcG5JHtesoUEzSngmOSTvu2jDic,12674
-kalavai_client-0.6.13.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kalavai_client-0.6.13.dist-info/METADATA,sha256=YUeJh_a81RDslXa8QNlgNwmXfQLHxAbqcCK2HWP6t-4,13354
-kalavai_client-0.6.13.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-kalavai_client-0.6.13.dist-info/entry_points.txt,sha256=9T6D45gxwzfVbglMm1r6XPdXuuZdHfy_7fCeu2jUphc,50
-kalavai_client-0.6.13.dist-info/RECORD,,
+kalavai_client/utils.py,sha256=S80bLSICvWLhtQP-dmW0OF4coKwjxmhmPIja8UArTTE,12712
+kalavai_client-0.6.14.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kalavai_client-0.6.14.dist-info/METADATA,sha256=UkJ77kexOEA-_8c9DwnphWnk6vZl1-1g2EGPNLJ9VHI,13354
+kalavai_client-0.6.14.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+kalavai_client-0.6.14.dist-info/entry_points.txt,sha256=9T6D45gxwzfVbglMm1r6XPdXuuZdHfy_7fCeu2jUphc,50
+kalavai_client-0.6.14.dist-info/RECORD,,