lemonade-sdk 8.1.5__py3-none-any.whl → 8.1.6__py3-none-any.whl

lemonade/tools/server/serve.py

@@ -9,7 +9,6 @@ import tempfile
 import traceback
 from typing import Optional, Union
 import json
-import subprocess
 from pathlib import Path
 
 from fastapi import FastAPI, HTTPException, status, Request
@@ -47,7 +46,8 @@ from openai.types.responses import (
 )
 
 import lemonade.api as lemonade_api
-import lemonade.tools.server.llamacpp as llamacpp
+from lemonade.tools.server.wrapped_server import WrappedServer
+from lemonade.tools.server.llamacpp import LlamaServer
 from lemonade.tools.server.tool_calls import extract_tool_calls, get_tool_call_pattern
 from lemonade.tools.server.webapp import get_webapp_html
 from lemonade.tools.server.utils.port import lifespan
@@ -232,11 +232,8 @@ class Server:
         # Add lock for load/unload operations
         self._load_lock = asyncio.Lock()
 
-        # Subprocess handle for llama_server.exe
-        self.llama_server_process: subprocess.Popen = None
-
-        # Telemetry instance for llama server
-        self.llama_telemetry = llamacpp.LlamaTelemetry()
+        # Subprocess handle for wrapped instance of llama_server.exe, etc.
+        self.wrapped_server: WrappedServer = None
 
     def setup_routes(self, api_prefixes: list[str]):
         for prefix in api_prefixes:
@@ -521,7 +518,7 @@ class Server:
         await self.load_llm(lc)
 
         if self.llm_loaded.recipe == "llamacpp":
-            return llamacpp.completion(completion_request, self.llama_telemetry)
+            return self.wrapped_server.completion(completion_request)
 
         # Check if the model supports reasoning
         reasoning_first_token = self.llm_loaded.reasoning
@@ -656,9 +653,7 @@ class Server:
         await self.load_llm(lc)
 
         if self.llm_loaded.recipe == "llamacpp":
-            return llamacpp.chat_completion(
-                chat_completion_request, self.llama_telemetry
-            )
+            return self.wrapped_server.chat_completion(chat_completion_request)
 
         # Convert chat messages to text using the model's chat template
         text = self.apply_chat_template(
@@ -861,7 +856,7 @@ class Server:
 
         if self.llm_loaded.recipe == "llamacpp":
             try:
-                return llamacpp.embeddings(embeddings_request, self.llama_telemetry)
+                return self.wrapped_server.embeddings(embeddings_request)
             except Exception as e:  # pylint: disable=broad-exception-caught
                 # Check if model has embeddings label
                 model_info = ModelManager().supported_models.get(
@@ -884,7 +879,7 @@ class Server:
 
     async def reranking(self, reranking_request: RerankingRequest):
         """
-        Rerank documents based on their relevance to a query using the llamacpp server.
+        Rerank documents based on their relevance to a query.
         """
         # Initialize load config from reranking request
         lc = LoadConfig(model_name=reranking_request.model)
@@ -894,7 +889,7 @@ class Server:
 
         if self.llm_loaded.recipe == "llamacpp":
             try:
-                return llamacpp.reranking(reranking_request, self.llama_telemetry)
+                return self.wrapped_server.reranking(reranking_request)
             except Exception as e:  # pylint: disable=broad-exception-caught
                 # Check if model has reranking label
                 model_info = ModelManager().supported_models.get(
@@ -1287,7 +1282,7 @@ class Server:
         """
         # If using llama server, get telemetry from the telemetry instance
         if self.llm_loaded and self.llm_loaded.recipe == "llamacpp":
-            return self.llama_telemetry.get_telemetry_data()
+            return self.wrapped_server.telemetry.get_telemetry_data()
 
         # For built-in server, use the existing telemetry
         return {
@@ -1466,9 +1461,9 @@ class Server:
             ):
                 if (
                     self.llm_loaded.recipe == "llamacpp"
-                    and self.llama_server_process.poll()
+                    and self.wrapped_server.process.poll()
                 ):
-                    # llama-server process has gone away for some reason, so we should
+                    # wrapped server process has gone away for some reason, so we should
                     # proceed with loading to get it back
                     pass
                 else:
@@ -1484,12 +1479,10 @@ class Server:
             logging.info(f"Loading llm: {config.model_name}")
             try:
                 if config_to_use.recipe == "llamacpp":
-                    self.llama_server_process = llamacpp.server_load(
+                    self.wrapped_server = LlamaServer(self.llamacpp_backend)
+                    self.wrapped_server.load(
                         model_config=config_to_use,
-                        telemetry=self.llama_telemetry,
-                        backend=self.llamacpp_backend,
                         ctx_size=self.ctx_size,
-                        # Models should only upgrade when using the pull endpoint
                         do_not_upgrade=True,
                     )
 
@@ -1530,7 +1523,7 @@ class Server:
                     await self._generate_semaphore.acquire()
 
             if self.llm_loaded.recipe == "llamacpp":
-                self.llama_server_process.terminate()
+                self.wrapped_server.process.terminate()
 
             self.llm_loaded = None
             self.tokenizer = None

lemonade/tools/server/wrapped_server.py

@@ -0,0 +1,485 @@
+import logging
+import time
+import subprocess
+from abc import ABC, abstractmethod
+
+import requests
+from tabulate import tabulate
+from fastapi import HTTPException, status
+from fastapi.responses import StreamingResponse
+
+from openai import OpenAI
+
+from lemonade_server.pydantic_models import (
+    ChatCompletionRequest,
+    CompletionRequest,
+    PullConfig,
+    EmbeddingsRequest,
+    RerankingRequest,
+)
+from lemonade_server.model_manager import ModelManager
+from lemonade.tools.server.utils.port import find_free_port
+
+
+class WrappedServerTelemetry(ABC):
+    """
+    Manages telemetry data collection and display for wrapped server.
+    """
+
+    def __init__(self):
+        self.input_tokens = None
+        self.output_tokens = None
+        self.time_to_first_token = None
+        self.tokens_per_second = None
+        self.prompt_eval_time = None
+        self.eval_time = None
+
+    @abstractmethod
+    def parse_telemetry_line(self, line: str):
+        """
+        Parse telemetry data from wrapped server output lines.
+        """
+
+    def get_telemetry_data(self):
+        return {
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "time_to_first_token": self.time_to_first_token,
+            "tokens_per_second": self.tokens_per_second,
+            "decode_token_times": None,
+        }
+
+    def show_telemetry(self):
+        # Check if debug logging is enabled
+        if not logging.getLogger().isEnabledFor(logging.DEBUG):
+            return
+
+        # Prepare telemetry data (transposed format)
+        telemetry = [
+            ["Input tokens", self.input_tokens],
+            ["Output tokens", self.output_tokens],
+            ["TTFT (s)", f"{self.time_to_first_token:.2f}"],
+            ["TPS", f"{self.tokens_per_second:.2f}"],
+        ]
+
+        table = tabulate(
+            telemetry, headers=["Metric", "Value"], tablefmt="fancy_grid"
+        ).split("\n")
+
+        # Show telemetry in debug while complying with uvicorn's log indentation
+        logging.debug("\n          ".join(table))
+
+
+class WrappedServer(ABC):
+    """
+    Abstract base class that defines the interface for Lemonade to "wrap" a server
+    like llama-server.
+    """
+
+    def __init__(self, server_name: str, telemetry: WrappedServerTelemetry):
+        self.port: int = None
+        self.process: subprocess.Popen = None
+        self.server_name: str = server_name
+        self.telemetry: WrappedServerTelemetry = telemetry
+
+    def choose_port(self):
+        """
+        Users probably don't care what port we start the wrapped server on, so let's
+        search for an empty port
+        """
+
+        self.port = find_free_port()
+
+        if self.port is None:
+            msg = f"Failed to find an empty port to start {self.server_name} on"
+            logging.error(msg)
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=msg,
+            )
+
+    def address(self) -> str:
+        """
+        Generate the base URL for the server.
+
+        Returns:
+            The base URL for the wrapped server
+        """
+        return f"http://127.0.0.1:{self.port}/v1"
+
+    def _separate_openai_params(
+        self,
+        request_dict: dict,
+        endpoint_type: str = "chat",
+    ) -> dict:
+        """
+        Separate standard OpenAI parameters from custom wrapped server parameters.
+
+        Args:
+            request_dict: Dictionary of all request parameters
+            endpoint_type: Type of endpoint ("chat" or "completion")
+
+        Returns:
+            Dictionary with parameters properly separated for OpenAI client
+        """
+        openai_client_params = {}
+        extra_params = {}
+
+        # Common OpenAI parameters for both endpoint types
+        common_params = {
+            "model",
+            "frequency_penalty",
+            "logit_bias",
+            "logprobs",
+            "max_tokens",
+            "n",
+            "presence_penalty",
+            "seed",
+            "stop",
+            "stream",
+            "temperature",
+            "top_p",
+            "user",
+        }
+
+        # Standard OpenAI parameters by endpoint type
+        if endpoint_type == "chat":
+            chat_specific_params = {
+                "messages",
+                "top_logprobs",
+                "response_format",
+                "service_tier",
+                "stream_options",
+                "tools",
+                "tool_choice",
+                "parallel_tool_calls",
+            }
+            openai_params = common_params | chat_specific_params
+        else:  # completion
+            completion_specific_params = {
+                "prompt",
+                "best_of",
+                "echo",
+                "suffix",
+            }
+            openai_params = common_params | completion_specific_params
+
+        for key, value in request_dict.items():
+            if key in openai_params:
+                openai_client_params[key] = value
+            else:
+                extra_params[key] = value
+
+        # If there are custom parameters, use extra_body to pass them through
+        if extra_params:
+            openai_client_params["extra_body"] = extra_params
+
+        return openai_client_params
+
+    def _log_subprocess_output(self, prefix: str):
+        """
+        Read subprocess output line by line, log to debug, and parse telemetry
+        """
+
+        if self.process.stdout:
+            try:
+                for line in iter(self.process.stdout.readline, ""):
+                    if line:
+                        line_stripped = line.strip()
+                        logging.debug("%s: %s", prefix, line_stripped)
+
+                        self.telemetry.parse_telemetry_line(line_stripped)
+
+                    if self.process.poll() is not None:
+                        break
+            except UnicodeDecodeError as e:
+                logging.debug(
+                    "Unicode decode error reading subprocess output: %s", str(e)
+                )
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                logging.error("Unexpected error reading subprocess output: %s", str(e))
+
+    def _wait_for_load(self):
+        status_code = None
+        while not self.process.poll() and status_code != 200:
+            health_url = f"http://localhost:{self.port}/health"
+            try:
+                health_response = requests.get(health_url)
+            except requests.exceptions.ConnectionError:
+                logging.debug(
+                    f"Not able to connect to {self.server_name} yet, will retry"
+                )
+            else:
+                status_code = health_response.status_code
+                logging.debug(
+                    f"Testing {self.server_name} readiness (will retry until ready), "
+                    f"result: {health_response.json()}"
+                )
+            time.sleep(1)
+
+    @abstractmethod
+    def _launch_server_subprocess(
+        self,
+        model_config: PullConfig,
+        snapshot_files: dict,
+        ctx_size: int,
+        supports_embeddings: bool = False,
+        supports_reranking: bool = False,
+    ):
+        """
+        Launch wrapped server subprocess with appropriate configuration.
+
+        Args:
+            snapshot_files: Dictionary of model files to load
+            supports_embeddings: Whether the model supports embeddings
+            supports_reranking: Whether the model supports reranking
+        """
+
+    @abstractmethod
+    def install_server(self, backend=None):
+        """
+        Install the wrapped server
+        """
+
+    @abstractmethod
+    def download_model(
+        self, config_checkpoint, config_mmproj=None, do_not_upgrade=False
+    ) -> dict:
+        """
+        Download a model for the wrapper server
+        """
+
+    def load(
+        self,
+        model_config: PullConfig,
+        ctx_size: int,
+        do_not_upgrade: bool = False,
+    ):
+        # Install and/or update the wrapped server if needed
+        try:
+            self.install_server()
+        except NotImplementedError as e:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
+            )
+
+        # Download the model to the hugging face cache
+        snapshot_files = self.download_model(
+            model_config.checkpoint, model_config.mmproj, do_not_upgrade=do_not_upgrade
+        )
+        logging.debug(f"Model file paths: {snapshot_files}")
+
+        # Check if model supports embeddings
+        supported_models = ModelManager().supported_models
+        model_info = supported_models.get(model_config.model_name, {})
+        supports_embeddings = "embeddings" in model_info.get("labels", [])
+        supports_reranking = "reranking" in model_info.get("labels", [])
+
+        self._launch_server_subprocess(
+            model_config=model_config,
+            snapshot_files=snapshot_files,
+            ctx_size=ctx_size,
+            supports_embeddings=supports_embeddings,
+            supports_reranking=supports_reranking,
+        )
+
+        # Check the /health endpoint until server is ready
+        self._wait_for_load()
+
+        if self.process.poll():
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Failed to load {model_config.model_name} with {self.server_name}",
+            )
+
+    def chat_completion(self, chat_completion_request: ChatCompletionRequest):
+        client = OpenAI(
+            base_url=self.address(),
+            api_key="lemonade",
+        )
+
+        # Convert Pydantic model to dict and remove unset/null values
+        request_dict = chat_completion_request.model_dump(
+            exclude_unset=True, exclude_none=True
+        )
+
+        # Separate standard OpenAI parameters from custom llama.cpp parameters
+        openai_client_params = self._separate_openai_params(request_dict, "chat")
+
+        # Check if streaming is requested
+        if chat_completion_request.stream:
+
+            def event_stream():
+                try:
+                    # Enable streaming
+                    # pylint: disable=missing-kwoa
+                    for chunk in client.chat.completions.create(**openai_client_params):
+                        yield f"data: {chunk.model_dump_json()}\n\n"
+                    yield "data: [DONE]\n\n"
+
+                    # Show telemetry after completion
+                    self.telemetry.show_telemetry()
+
+                except Exception as e:  # pylint: disable=broad-exception-caught
+                    yield f'data: {{"error": "{str(e)}"}}\n\n'
+
+            return StreamingResponse(
+                event_stream(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                },
+            )
+        else:
+            # Non-streaming response
+            try:
+                # Disable streaming for non-streaming requests
+                # pylint: disable=missing-kwoa
+                response = client.chat.completions.create(**openai_client_params)
+
+                # Show telemetry after completion
+                self.telemetry.show_telemetry()
+
+                return response
+
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                logging.error("Error during chat completion: %s", str(e))
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail=f"Chat completion error: {str(e)}",
+                )
+
+    def completion(self, completion_request: CompletionRequest):
+        """
+        Handle text completions using the wrapped server.
+
+        Args:
+            completion_request: The completion request containing prompt and parameters
+            telemetry: Telemetry object containing the server port
+
+        Returns:
+            Completion response from the wrapped server
+        """
+
+        client = OpenAI(
+            base_url=self.address(),
+            api_key="lemonade",
+        )
+
+        # Convert Pydantic model to dict and remove unset/null values
+        request_dict = completion_request.model_dump(
+            exclude_unset=True, exclude_none=True
+        )
+
+        # Separate standard OpenAI parameters from custom llama.cpp parameters
+        openai_client_params = self._separate_openai_params(request_dict, "completion")
+
+        # Check if streaming is requested
+        if completion_request.stream:
+
+            def event_stream():
+                try:
+                    # Enable streaming
+                    # pylint: disable=missing-kwoa
+                    for chunk in client.completions.create(**openai_client_params):
+                        yield f"data: {chunk.model_dump_json()}\n\n"
+                    yield "data: [DONE]\n\n"
+
+                    # Show telemetry after completion
+                    self.telemetry.show_telemetry()
+
+                except Exception as e:  # pylint: disable=broad-exception-caught
+                    yield f'data: {{"error": "{str(e)}"}}\n\n'
+
+            return StreamingResponse(
+                event_stream(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                },
+            )
+        else:
+            # Non-streaming response
+            try:
+                # Disable streaming for non-streaming requests
+                # pylint: disable=missing-kwoa
+                response = client.completions.create(**openai_client_params)
+
+                # Show telemetry after completion
+                self.telemetry.show_telemetry()
+
+                return response
+
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                logging.error("Error during completion: %s", str(e))
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail=f"Completion error: {str(e)}",
+                )
+
+    def embeddings(self, embeddings_request: EmbeddingsRequest):
+        """
+        Generate embeddings using the wrapped server.
+
+        Args:
+            embeddings_request: The embeddings request containing input text/tokens
+            telemetry: Telemetry object containing the server port
+
+        Returns:
+            Embeddings response from the wrapped server
+        """
+        client = OpenAI(
+            base_url=self.address(),
+            api_key="lemonade",
+        )
+
+        # Convert Pydantic model to dict and remove unset/null values
+        request_dict = embeddings_request.model_dump(
+            exclude_unset=True, exclude_none=True
+        )
+
+        try:
+            # Call the embeddings endpoint
+            response = client.embeddings.create(**request_dict)
+            return response
+
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Embeddings error: {str(e)}",
+            )
+
+    def reranking(self, reranking_request: RerankingRequest):
+        """
+        Rerank documents based on their relevance to a query using the wrapped server.
+
+        Args:
+            reranking_request: The reranking request containing query and documents
+            telemetry: Telemetry object containing the server port
+
+        Returns:
+            Reranking response from the wrapped server containing ranked documents and scores
+        """
+
+        try:
+            # Convert Pydantic model to dict and exclude unset/null values
+            request_dict = reranking_request.model_dump(
+                exclude_unset=True, exclude_none=True
+            )
+
+            # Call the reranking endpoint directly since it's not supported by the OpenAI API
+            response = requests.post(
+                f"{self.address()}/rerank",
+                json=request_dict,
+            )
+            response.raise_for_status()
+            return response.json()
+
+        except Exception as e:
+            logging.error("Error during reranking: %s", str(e))
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Reranking error: {str(e)}",
+            ) from e

lemonade/version.py

@@ -1 +1 @@
-__version__ = "8.1.5"
+__version__ = "8.1.6"

{lemonade_sdk-8.1.5.dist-info → lemonade_sdk-8.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lemonade-sdk
-Version: 8.1.5
+Version: 8.1.6
 Summary: Lemonade SDK: Your LLM Aide for Validation and Deployment
 Author-email: lemonade@amd.com
 Requires-Python: >=3.10, <3.14

{lemonade_sdk-8.1.5.dist-info → lemonade_sdk-8.1.6.dist-info}/RECORD

@@ -4,7 +4,7 @@ lemonade/cache.py,sha256=5iZbk273TiTMqK_vdzPOPYTo6VsWW2gNByOISA9zi1w,3002
 lemonade/cli.py,sha256=9Pcs3PcrWC2F8_pcBaz09xHUICIJTvpemBdPGyXkjIk,4395
 lemonade/sequence.py,sha256=KSH7BPsiyDKsOsg_ziQKEGsDwMmuO_YbgPRBxkZd0pw,13267
 lemonade/state.py,sha256=sdSezla7Cd7KYL90xY3p9kcNV4ndSyN6UvNLOr3vBMA,5261
-lemonade/version.py,sha256=UE2byv3TrjFSpmrlMMLljjtWoisXIAZ0MoNAF9Lc36k,22
+lemonade/version.py,sha256=pLCv7QgPYSVaHwGzgyRgNowjqjppvm3TmtmQCvVkOrA,22
 lemonade/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lemonade/common/build.py,sha256=zTb0m1-kuUx6zw5QHp2SNnVuN6jOTMQ2FCdj9iH374U,6140
 lemonade/common/cli_helpers.py,sha256=hjBfXrTtFl8gmCFlL-ksviXR0mOcdPtTWVNKoEp3PG4,4993
@@ -34,7 +34,7 @@ lemonade/tools/huggingface/load.py,sha256=KsSGOBBD-tNEIfYC8mCWV_jpnkjHMhN3juVmC1
 lemonade/tools/huggingface/utils.py,sha256=j1S-IgjDsznUIVwkHSqqChmFyqIx9f3WcEelzohWwvU,13955
 lemonade/tools/llamacpp/bench.py,sha256=1fkE02ecg-jRk92i5dTAXz6re14WH8bd-Z9l-m3lbDA,4844
 lemonade/tools/llamacpp/load.py,sha256=DFCvQN548Ch9H8U_rHOiYviinzw6vixb5-V7xLj7XE4,6499
-lemonade/tools/llamacpp/utils.py,sha256=LZ0xae7tTQG9nP55DLm90PJS8UQEwGJmMIb_96pWDKE,32397
+lemonade/tools/llamacpp/utils.py,sha256=96POJXoIBE_zLArusiOrgyCcz8D5vR3IuXkMzyg79CU,32608
 lemonade/tools/oga/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lemonade/tools/oga/bench.py,sha256=PJXv4UchcS2YPwijNzef8DY4DSAKYxIYY1ycHuH3T34,5005
 lemonade/tools/oga/load.py,sha256=BH5ChYbZgeP_ZN4E6HoboJD3kZcUIAPgPEVbgUZpVjQ,33778
@@ -46,11 +46,12 @@ lemonade/tools/report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 lemonade/tools/report/llm_report.py,sha256=bVHhwCINA-Ok2EdSwAsLubsc83N3KWOVuwTguw7jDcE,6676
 lemonade/tools/report/table.py,sha256=ssqy1bZqF-wptNzKEOj6_9REtCNZyXO8R5vakAtg3R4,27973
 lemonade/tools/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lemonade/tools/server/llamacpp.py,sha256=9OneTx78UgvTzvZbdQidiihAN4F-JyfmhwD0bnj5_IU,21090
-lemonade/tools/server/serve.py,sha256=qA0BqYEeRKXtEoS-hG20M_b1WXiiDmyvfEAk72s6XTc,60573
+lemonade/tools/server/llamacpp.py,sha256=w-M0JXrgXVpfICnHBHhJm_yBshfwZ8zge-e1o1kH0R4,8751
+lemonade/tools/server/serve.py,sha256=YVsO7m9E1OsQtbcjkv_1ir8oCSAdr0IXGNEvJ6FKamw,60311
 lemonade/tools/server/tool_calls.py,sha256=xrAlQwKG-nv2xLlf8f9CDSaUbyMn8ZtHkds9iZLG9K8,5230
 lemonade/tools/server/tray.py,sha256=a9z6hdqlfj91H00j6hAExRPQkzWHhE3dnqSumzEgq0U,19599
 lemonade/tools/server/webapp.py,sha256=8Das5yXOaSBLZmSZ_eddJajQFxBhvl5D6GI_hHlGbE0,1040
+lemonade/tools/server/wrapped_server.py,sha256=-knOr2ycmrebVPYrOlCNRJH0ySZPnVlWzbKYLsfTRhE,16441
 lemonade/tools/server/static/favicon.ico,sha256=hMmP9qGJNeZ0mFS86JIqPbZstXMZn0Z76_HfHQpREAU,126745
 lemonade/tools/server/static/styles.css,sha256=5HQQCpm8N_fzLcolPiDuhyZw_5nbO8aIl60xAn4RKmg,43385
 lemonade/tools/server/static/webapp.html,sha256=FX2MZUsljfgxxuF12KBdgvNkso_z-sHewWc0SEGGcGM,18138
@@ -63,15 +64,15 @@ lemonade/tools/server/utils/system_tray.py,sha256=b9lvNv9chJKQxvmH7qzAuUe6H9HsLu
 lemonade/tools/server/utils/thread.py,sha256=Z-PDzGcpgfN2qxTmtlROWqrUN0B2fXdPrqo_J10fR_w,2772
 lemonade_install/__init__.py,sha256=26zohKg2jgr_5y7tObduWMYQg8zCTWMZHL8lfi2zZVQ,40
 lemonade_install/install.py,sha256=onndA2a-ygyLtDfupI8JQFhU_XpK8McGZtGujFasXww,28304
-lemonade_sdk-8.1.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lemonade_sdk-8.1.5.dist-info/licenses/NOTICE.md,sha256=RSca9LE5e6pvdWA_LXAUCcACIHPmINKqkRX-AVRqBGo,3499
-lemonade_server/cli.py,sha256=-oRbLRlOX6SRH1bZURmlkDujsUBwMVprm83MtVR3DEY,18819
-lemonade_server/model_manager.py,sha256=8FsD234ODtqVF3k4GIjo6UnZKSpii11UU_zoIf-kvSU,11133
+lemonade_sdk-8.1.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lemonade_sdk-8.1.6.dist-info/licenses/NOTICE.md,sha256=RSca9LE5e6pvdWA_LXAUCcACIHPmINKqkRX-AVRqBGo,3499
+lemonade_server/cli.py,sha256=GsYMg095XMADHjWr1ytLYvbbrtSDPwQJEUn0gI-W99o,19108
+lemonade_server/model_manager.py,sha256=DVznjSHG5R_W3E5xTI-7p4qYS_NTS3ssXh4zujeey-Y,20453
 lemonade_server/pydantic_models.py,sha256=49MyOlb5feLUlKsGcI75tWaflWckrItqcSVkdCY4e3A,3269
 lemonade_server/server_models.json,sha256=DAdG4ebIt5Dy5MM3kmXn1pO0XbNMph1gdpzbacBDVuc,11664
 lemonade_server/settings.py,sha256=6nsmPLFJD-UokQDmlx9ZBYMbpnn48So_PuBGWP7Fmfg,1299
-lemonade_sdk-8.1.5.dist-info/METADATA,sha256=DqkuNfUnA3CgSvDSVkz6cQJnQBw75AE9FmbAAoRdrso,16852
-lemonade_sdk-8.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lemonade_sdk-8.1.5.dist-info/entry_points.txt,sha256=7sRvpNhi1E7amnM7RZo57e8yFF9iA5uuRaIeJ1Xre6w,193
-lemonade_sdk-8.1.5.dist-info/top_level.txt,sha256=10ap5GNiPhalO4V50LRoxA1FqRT9g3Xkia6BITu880k,42
-lemonade_sdk-8.1.5.dist-info/RECORD,,
+lemonade_sdk-8.1.6.dist-info/METADATA,sha256=N6NlWOitXA4TrHkebCpHS9d2QZ4LtaY0aOWJvaz8TXU,16852
+lemonade_sdk-8.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lemonade_sdk-8.1.6.dist-info/entry_points.txt,sha256=7sRvpNhi1E7amnM7RZo57e8yFF9iA5uuRaIeJ1Xre6w,193
+lemonade_sdk-8.1.6.dist-info/top_level.txt,sha256=10ap5GNiPhalO4V50LRoxA1FqRT9g3Xkia6BITu880k,42
+lemonade_sdk-8.1.6.dist-info/RECORD,,