WIP on precommit

Author: abrookins

.pre-commit-config.yaml

@@ -0,0 +1,17 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.3.2  # Use the latest version
+    hooks:
+      # Run the linter
+      - id: ruff
+        args: [--fix]
+      # Run the formatter
+      - id: ruff-format
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files 

models.py

@@ -1,13 +1,13 @@
-from typing import Dict, List, Optional, Union, Any
-import numpy as np
-from pydantic import BaseModel, Field
-from openai import AsyncOpenAI, ChatCompletion
-import os
 import logging
+import os
 from enum import Enum
-import asyncio
-from redis.asyncio import ConnectionPool, Redis
+from typing import Any
+
 import anthropic
+import numpy as np
+from openai import AsyncOpenAI
+from pydantic import BaseModel, Field
+
 
 # Setup logging
 logger = logging.getLogger(__name__)
@@ -23,16 +23,16 @@ class MemoryMessage(BaseModel):
 class MemoryMessagesAndContext(BaseModel):
     """Request payload for adding messages to memory"""
 
-    messages: List[MemoryMessage]
-    context: Optional[str] = None
+    messages: list[MemoryMessage]
+    context: str | None = None
 
 
 class MemoryResponse(BaseModel):
     """Response containing messages and context"""
 
-    messages: List[MemoryMessage]
-    context: Optional[str] = None
-    tokens: Optional[int] = None
+    messages: list[MemoryMessage]
+    context: str | None = None
+    tokens: int | None = None
 
 
 class SearchPayload(BaseModel):
@@ -59,27 +59,27 @@ class RedisearchResult(BaseModel):
     role: str
     content: str
     dist: float
-    
-    
+
+
 class SearchResults(BaseModel):
     """Results from a redisearch query"""
 
-    docs: List[RedisearchResult]
+    docs: list[RedisearchResult]
     total: int
 
 
 class NamespaceQuery(BaseModel):
     """Query parameters for namespace"""
 
-    namespace: Optional[str] = None
+    namespace: str | None = None
 
 
 class GetSessionsQuery(BaseModel):
     """Query parameters for getting sessions"""
 
     page: int = Field(default=1)
     size: int = Field(default=20)
-    namespace: Optional[str] = None
+    namespace: str | None = None
 
 
 class ModelProvider(str, Enum):
@@ -260,7 +260,7 @@ def get_model_config(model_name: str) -> ModelConfig:
 class ChatResponse:
     """Unified wrapper for chat responses from different providers"""
 
-    def __init__(self, choices: List[Any], usage: Dict[str, int]):
+    def __init__(self, choices: list[Any], usage: dict[str, int]):
         self.choices = choices or []
         self.usage = usage or {"total_tokens": 0}
 
@@ -319,7 +319,7 @@ async def create_chat_completion(self, model: str, prompt: str) -> ChatResponse:
             logger.error(f"Error creating chat completion with Anthropic: {e}")
             raise
 
-    async def create_embedding(self, query_vec: List[str]) -> np.ndarray:
+    async def create_embedding(self, query_vec: list[str]) -> np.ndarray:
         """
         Create embeddings for the given texts
         Note: Anthropic doesn't offer an embedding API, so we'll use OpenAI's
@@ -345,22 +345,27 @@ def __init__(self, api_key: str | None = None, base_url: str | None = None):
 
         if openai_api_base:
             self.completion_client = AsyncOpenAI(
-                api_key=openai_api_key, base_url=openai_api_base
+                api_key=openai_api_key,
+                base_url=openai_api_base,
             )
             self.embedding_client = AsyncOpenAI(
-                api_key=openai_api_key, base_url=openai_api_base
+                api_key=openai_api_key,
+                base_url=openai_api_base,
             )
         else:
             self.completion_client = AsyncOpenAI(api_key=openai_api_key)
             self.embedding_client = AsyncOpenAI(api_key=openai_api_key)
 
     async def create_chat_completion(
-        self, model: str, progressive_prompt: str
+        self,
+        model: str,
+        progressive_prompt: str,
     ) -> ChatResponse:
         """Create a chat completion using the OpenAI API"""
         try:
             response = await self.completion_client.chat.completions.create(
-                model=model, messages=[{"role": "user", "content": progressive_prompt}]
+                model=model,
+                messages=[{"role": "user", "content": progressive_prompt}],
             )
 
             # Convert to unified format
@@ -380,7 +385,7 @@ async def create_chat_completion(
             logger.error(f"Error creating chat completion with OpenAI: {e}")
             raise
 
-    async def create_embedding(self, query_vec: List[str]) -> np.ndarray:
+    async def create_embedding(self, query_vec: list[str]) -> np.ndarray:
         """Create embeddings for the given texts"""
         try:
             embeddings = []
@@ -391,7 +396,8 @@ async def create_embedding(self, query_vec: List[str]) -> np.ndarray:
             for i in range(0, len(query_vec), batch_size):
                 batch = query_vec[i : i + batch_size]
                 response = await self.embedding_client.embeddings.create(
-                    model=embedding_model, input=batch
+                    model=embedding_model,
+                    input=batch,
                 )
                 batch_embeddings = [item.embedding for item in response.data]
                 embeddings.extend(batch_embeddings)
@@ -408,13 +414,13 @@ class ModelClientFactory:
     @staticmethod
     async def get_client(
         model_name: str,
-    ) -> Union[OpenAIClientWrapper, AnthropicClientWrapper]:
+    ) -> OpenAIClientWrapper | AnthropicClientWrapper:
         """Get the appropriate client for a model"""
         model_config = get_model_config(model_name)
 
         if model_config.provider == ModelProvider.OPENAI:
             return OpenAIClientWrapper(api_key=os.environ.get("OPENAI_API_KEY"))
-        elif model_config.provider == ModelProvider.ANTHROPIC:
+        if model_config.provider == ModelProvider.ANTHROPIC:
             return AnthropicClientWrapper(api_key=os.environ.get("ANTHROPIC_API_KEY"))
-        else:
-            raise ValueError(f"Unsupported model provider: {model_config.provider}")
+
+        raise ValueError(f"Unsupported model provider: {model_config.provider}")

pyproject.toml

@@ -0,0 +1,51 @@
+[tool.ruff]
+# Exclude a variety of commonly ignored directories
+exclude = [
+    ".git",
+    ".github",
+    ".pytest_cache",
+    "__pycache__",
+    "env",
+    "venv",
+    ".venv",
+    "*.egg-info",
+]
+
+# Same as Black
+line-length = 88
+
+# Assume Python 3.10
+target-version = "py310"
+
+[tool.ruff.lint]
+# Enable various rules
+select = ["E", "F", "B", "I", "N", "UP", "C4", "PT", "RET", "SIM", "TID"]
+# Exclude COM812 which conflicts with the formatter
+ignore = ["COM812"]
+
+# Allow unused variables when underscore-prefixed
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+# Fix code when possible
+fixable = ["ALL"]
+unfixable = []
+
+[tool.ruff.lint.mccabe]
+# Flag functions with high cyclomatic complexity
+max-complexity = 10
+
+[tool.ruff.lint.isort]
+# Group imports by type and organize them alphabetically
+known-first-party = ["redis-memory-server"]
+section-order = ["future", "standard-library", "third-party", "first-party", "local-folder"]
+combine-as-imports = true
+lines-after-imports = 2
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.format]
+# Use double quotes for strings
+quote-style = "double"
+# Use spaces for indentation
+indent-style = "space" 

requirements-dev.txt

@@ -1,3 +1,5 @@
 pytest
 pytest-asyncio
 testcontainers
+pre-commit
+ruff>=0.3.0

requirements.txt

@@ -10,6 +10,6 @@ python-multipart>=0.0.6
 tiktoken>=0.5.1
 structlog>=23.2.0
 async-timeout>=4.0.3
-httpx>=0.25.1 
-numpy>=
+httpx>=0.25.1
+numpy>=2.2.3
 pydantic-settings>=2.8.1

setup-dev.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+# Exit on error
+set -e
+
+echo "Setting up development environment..."
+
+# Create a virtual environment if it doesn't exist
+if [ ! -d "env" ]; then
+    echo "Creating virtual environment..."
+    python -m venv env
+fi
+
+# Activate the virtual environment
+source env/bin/activate
+
+# Install dependencies
+echo "Installing development dependencies..."
+pip install -r requirements.txt
+pip install -r requirements-dev.txt
+
+# Set up pre-commit hooks
+echo "Setting up pre-commit hooks..."
+pre-commit install
+
+echo "Development environment setup complete!"
+echo "You can now run 'pre-commit run --all-files' to check all files in the repository."