fix: additional linting fixes for inference-mock

Signed-off-by: Emilio Garcia <[email protected]>

Author: iamemilio

actions/inference-mock/README.md

@@ -22,7 +22,7 @@ debug: True
 
 # port: the port the server will listen on
 # optional: this defaults to 11434
-port: 11343
+port: 11434
 
 # matches: a list of matching strategies for expected sets of prompt response pairs. The following strategies are available:
 #   - contains: accepts a list of substrings. All incoming prompts will need to contain all listed substrings for this match to be positive

actions/inference-mock/app.py

@@ -1,35 +1,40 @@
-from flask import Flask, request # type: ignore[import-not-found]
-from werkzeug import exceptions # type: ignore[import-not-found]
-
-from completions.completion import create_chat_completion
+# Standard
 from dataclasses import dataclass
-from matching.matching import Matcher
-
-import click # type: ignore[import-not-found]
 import logging
 import pprint
-import yaml
 
+# Third Party
+from completions.completion import create_chat_completion
+from flask import Flask, request  # type: ignore[import-not-found]
+from matching.matching import Matcher
+from werkzeug import exceptions  # type: ignore[import-not-found]
+import click  # type: ignore[import-not-found]
+import yaml
 
 # Globals
 app = Flask(__name__)
+strategies: Matcher  # a read only list of matching strategies
 
 
 # Routes
-@app.route('/v1/completions', methods=['POST'])
+@app.route("/v1/completions", methods=["POST"])
 def completions():
     data = request.get_json()
-    if not data or 'prompt' not in data:
+    if not data or "prompt" not in data:
         raise exceptions.BadRequest("prompt is empty or None")
 
-    prompt_debug_str = data['prompt'][:90] + "..."
-    logger.debug(f"{request.method} {request.url} {data['model']} {prompt_debug_str}")
+    prompt_debug_str = data["prompt"][:90] + "..."
+    app.logger.debug(
+        f"{request.method} {request.url} {data['model']} {prompt_debug_str}"
+    )
 
-    prompt = data.get('prompt')
-    chat_response = strategies.find_match(prompt)  # handle prompt and generate correct response
+    prompt = data.get("prompt")
+    chat_response = strategies.find_match(
+        prompt
+    )  # handle prompt and generate correct response
 
-    response = create_chat_completion(chat_response, model=data.get('model'))
-    logger.debug(f"response: {pprint.pformat(response, compact=True)}")
+    response = create_chat_completion(chat_response, model=data.get("model"))
+    app.logger.debug(f"response: {pprint.pformat(response, compact=True)}")
     return response
 
 
@@ -42,31 +47,35 @@ class Config:
 
 
 @click.command()
-@click.option("--config", type=click.Path(), required=True, help='path to a YAML config file containing detailed configuration and model response options')
+@click.option(
+    "--config",
+    type=click.Path(),
+    required=True,
+    help="path to a YAML config file containing detailed configuration and model response options",
+)
 def start_server(config):
-    # globals
-    global logger
-    global strategies
-
     # get config
-    with open(config, 'r', encoding="utf-8") as file:
+    with open(config, "r", encoding="utf-8") as file:
         yaml_data = yaml.safe_load(file)
     if not isinstance(yaml_data, dict):
         raise ValueError("config file format is invalid")
 
     conf = Config(**yaml_data)
 
-    # set globals
-    strategies = Matcher(conf.matches)
-    logger = logging.getLogger(__name__)
+    # configure logger
     if conf.debug:
-        logging.basicConfig(level=logging.DEBUG, format='%(message)s')
+        app.logger.setLevel(logging.DEBUG)
+        app.logger.debug("debug mode enabled")
     else:
-        logging.basicConfig(level=logging.INFO, format='%(message)s')
+        app.logger.setLevel(logging.INFO)
+
+    # create match strategy object
+    global strategies  # pylint: disable=global-statement
+    strategies = Matcher(conf.matches)
 
     # init server
     app.run(debug=conf.debug, port=conf.port)
 
 
-if __name__ == '__main__':
-    start_server()
+if __name__ == "__main__":
+    start_server()  # pylint: disable=no-value-for-parameter

actions/inference-mock/completions/completion.py

@@ -1,12 +1,14 @@
 # mock openAI completion responses
 # credit: https://github.com/openai/openai-python/issues/715#issuecomment-1809203346
 # License: MIT
+
+# Standard
 import random
 
 
-def create_chat_completion(content: str, model: str="gpt-3.5") -> dict:
+def create_chat_completion(content: str, model: str = "gpt-3.5") -> dict:
     response = {
-        "id": f"chatcmpl-2nYZXNHxx1PeK1u8xXcE1Fqr1U6Ve",
+        "id": "chatcmpl-2nYZXNHxx1PeK1u8xXcE1Fqr1U6Ve",
         "object": "chat.completion",
         "created": "12345678",
         "model": model,
@@ -17,14 +19,14 @@ def create_chat_completion(content: str, model: str="gpt-3.5") -> dict:
                 "content": content,
                 "index": 0,
                 "logprobs": None,
-                "finish_reason": "length"
+                "finish_reason": "length",
             },
         ],
         "usage": {
             "prompt_tokens": random.randint(10, 500),
             "completion_tokens": random.randint(10, 500),
-            "total_tokens":random.randint(10, 500),
-        }
+            "total_tokens": random.randint(10, 500),
+        },
     }
 
     return response

actions/inference-mock/matching/matching.py

@@ -1,45 +1,47 @@
-from typing import Protocol
+# Standard
 from abc import abstractmethod
-
+from typing import Protocol
 import pprint
 
 
 class Match(Protocol):
-    '''
+    """
     Match represnts a single prompt matching
     strategy. When a match is successful,
     the response is what should be returned.
-    '''
+    """
 
     response: str
 
     @abstractmethod
-    def match(self, prompt:str) -> str|None:
+    def match(self, prompt: str) -> str | None:
         raise NotImplementedError
 
 
 class Always:
-    '''
+    """
     Always is a matching strategy that always
     is a positive match on a given prompt.
 
     This is best used when only one prompt response
     is expected.
-    '''
+    """
 
     def __init__(self, response: str):
         self.response = response
 
-    def match(self, prompt:str) -> str|None:
-        return self.response
+    def match(self, prompt: str) -> str | None:
+        if prompt:
+            return self.response
+        return None
 
 
 class Contains:
-    '''
+    """
     Contains is a matching strategy that checks
     if the prompt string contains all of
     the substrings in the `contains` attribute.
-    '''
+    """
 
     contains: list[str]
 
@@ -49,7 +51,9 @@ def __init__(self, contains: list[str], response: str):
         self.response = response
         self.contains = contains
 
-    def match(self, prompt:str) -> str|None:
+    def match(self, prompt: str) -> str | None:
+        if not prompt:
+            return None
         for context in self.contains:
             if context not in prompt:
                 return None
@@ -58,30 +62,32 @@ def match(self, prompt:str) -> str|None:
 
 
 class Matcher:
-    '''
-    Matcher matches prompt context and then 
+    """
+    Matcher matches prompt context and then
     selects a user provided reply.
-    '''
+    """
 
     strategies: list[Match]
 
-    def __init__(self, matching_patterns:list[dict]):
+    def __init__(self, matching_patterns: list[dict]):
         if not matching_patterns:
-            raise ValueError("matching strategies must contain at least one Match strategy")
+            raise ValueError(
+                "matching strategies must contain at least one Match strategy"
+            )
 
         self.strategies: list[Match] = []
         for matching_pattern in matching_patterns:
-            response = matching_pattern.get('response')
+            response = matching_pattern.get("response")
             if not response:
-                raise ValueError(f"matching strategy must have a response: {pprint.pformat(matching_pattern, compact=True)}")
-            if 'contains' in matching_pattern:
-                pattern = Contains(**matching_pattern)
+                raise ValueError(
+                    f"matching strategy must have a response: {pprint.pformat(matching_pattern, compact=True)}"
+                )
+            if "contains" in matching_pattern:
+                self.strategies.append(Contains(**matching_pattern))
             else:
-                pattern = Always(response)
-            self.strategies.append(pattern)
+                self.strategies.append(Always(response))
 
-    
-    def find_match(self, prompt:str) -> str:
+    def find_match(self, prompt: str) -> str:
         for strategy in self.strategies:
             response = strategy.match(prompt)
             if response: