folder-classifier 0.3.8__tar.gz → 0.4.0__tar.gz

{folder_classifier-0.3.8 → folder_classifier-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: folder-classifier
-Version: 0.3.8
+Version: 0.4.0
 Summary: Deploy folder classifier API to a Ray cluster
 Author: Crispin Almodovar
 Author-email: 

{folder_classifier-0.3.8 → folder_classifier-0.4.0}/folder_classifier/app.py

@@ -16,11 +16,13 @@ class FolderClassifierAPI:
         assert model_config.app_name and model_config.deployment, "Invalid ModelConfig values"
         logging.basicConfig(level=logging.INFO)
         self.logger = logging.getLogger(__name__)
-        self.classifier = FolderClassifier(app_name=model_config.app_name, deployment=model_config.deployment, model=model_config.model)
+        self.classifier = FolderClassifier(app_name=model_config.app_name, deployment=model_config.deployment, model=model_config.model,
+                                           fallback_config = model_config.fallback)
         self.logger.info(f"Successfully initialized Folder Classifier API using config: {model_config}")
 
     @web_api.post("/predict")
     async def predict(self, request: FolderClassificationRequest) -> FolderClassificationResponse:
-        self.logger.info(f"Received request: {request}")
+        self.logger.info(f"Received new request")
         category, reasoning = await self.classifier.predict(request)
+        self.logger.info(f"Request with items: {request.items} classified as '{category}' with reasoning: '{reasoning}'")
         return FolderClassificationResponse(category=category, reasoning=reasoning)

{folder_classifier-0.3.8 → folder_classifier-0.4.0}/folder_classifier/classifier.py

@@ -1,14 +1,20 @@
 import json
 import logging
-from typing import Tuple, Dict, Any
+from typing import Tuple, Dict, Any, Optional
+import os
 
+from openai import AsyncOpenAI
 from ray import serve
 
-from folder_classifier.dto import FolderClassificationRequest, FolderClassification
+from folder_classifier.dto import FolderClassificationRequest, FolderClassification, FallbackConfig
 from folder_classifier.util import build_folder, render_tree
 
-SYSTEM_PROMPT = r"""
-You are a strict text classifier. Provide a single JSON object with exactly two keys: "category" and "reasoning".
+
+
+
+SYSTEM_PROMPT = """
+You are an expert paralegal. Using only the evidence provided, decide if a root folder and its contents represent a single legal matter for a client.
+Follow only the decision rules included in the user message. Respond with exactly one minified JSON object with exactly two keys: "category" and "reasoning".
 - "category": either "matter" or "other" (lowercase).
 - "reasoning": 1–2 short explanation referencing the key rule(s) that decided it.
 No markdown (no backticks or code blocks) or any extra text outside the JSON. No chain-of-thought explanations or extra keys. If uncertain, choose "other".
@@ -80,17 +86,24 @@ FOLDER_CLASSIFICATION_SCHEMA = FolderClassification.model_json_schema()
 
 
 class FolderClassifier:
-    def __init__(self, app_name: str, deployment: str, model: str):
+    def __init__(self, app_name: str, deployment: str, model: str, fallback_config: Optional[FallbackConfig] = None):
         self.logger = logging.getLogger(__name__)
         self.model_handle = serve.get_deployment_handle(app_name=app_name, deployment_name=deployment)
         self.model = model
-        self.logger.info(f"Successfully initialized Folder Classifier with remote Ray model: {self.model}")
+        self.fallback_config = fallback_config
+        self.openai_client = AsyncOpenAI(base_url=self.fallback_config.openai_base_url, api_key=self.fallback_config.openai_api_key) \
+            if self.fallback_config else None
+
+        msg = f"Successfully initialized Folder Classifier with remote Ray model: {self.model}"
+        if self.fallback_config:
+            msg += f" and fallback - URL: {self.fallback_config.openai_base_url}; model: {self.fallback_config.model}"
+        self.logger.info(msg)
 
     async def predict(self, request: FolderClassificationRequest) -> Tuple[str, str]:
         content = ""
         try:
             chat_completion_request = self._to_chat_completion_request(request)
-            response = await self.model_handle.create_chat_completion_internal.remote(chat_completion_request)
+            response = await self.run_chat_completion(chat_completion_request)
             response_dict = json.loads(response.body)
             content = response_dict["choices"][0]["message"]["content"]
             result = FolderClassification.model_validate_json(content)
@@ -102,6 +115,17 @@ class FolderClassifier:
                 result = FolderClassification(category="other", reasoning="NA")
         return result.category, result.reasoning
 
+    async def run_chat_completion(self, chat_completion_request: dict[str, Any]) -> Any:
+        response = None
+        try:
+            response = await self.model_handle.create_chat_completion_internal.remote(chat_completion_request)
+        except Exception as ex:
+            self.logger.warning(f"Failed to invoke primary model {chat_completion_request['model']}. {ex}")
+            if self.fallback_config:
+                self.logger.info(f"Invoking fallback OpenAI model: {self.fallback_config.model}")
+                response = await self.openai_client.chat.completions.create(**chat_completion_request)
+        return response
+
     def _to_chat_completion_request(self, request: FolderClassificationRequest) -> Dict[str, Any]:
         input_paths = request.items
         folder = build_folder(input_paths)
@@ -116,7 +140,7 @@ class FolderClassifier:
                                                 replace("{folder_tree}", folder_tree)}
             ],
             "max_tokens": 1024,
-            "temperature": 0.7,
+            "temperature": 0.2,
             "top_p": 0.8,
             "response_format": {
                 "type": "json_schema",

{folder_classifier-0.3.8 → folder_classifier-0.4.0}/folder_classifier/deploy.py

@@ -2,11 +2,16 @@ from ray.serve import Application
 
 from folder_classifier.app import FolderClassifierAPI
 from folder_classifier.dto import AppConfig
+from folder_classifier.util import get_openapi_key
 
 
 def build_app(args: AppConfig) -> Application:
     assert args and args.model, "AppConfig model is required"
     assert args.model.app_name and args.model.deployment, "Model's app_name and deployment are required"
 
+    if args.model.fallback and args.model.fallback.openai_base_url and args.model.fallback.model:
+        if not args.model.fallback.openai_api_key:
+            args.model.fallback.openai_api_key = get_openapi_key()
+
     app = FolderClassifierAPI.bind(args.model)
     return app

{folder_classifier-0.3.8 → folder_classifier-0.4.0}/folder_classifier/dto.py

@@ -2,10 +2,17 @@ from typing import List, Union, Literal, Optional
 from pydantic import BaseModel, Field, ConfigDict
 
 
+class FallbackConfig(BaseModel):
+    openai_base_url: str
+    openai_api_key: Optional[str] = None
+    model: str
+
+
 class ModelConfig(BaseModel):
     app_name: str
     deployment: str
     model: str
+    fallback: Optional[FallbackConfig] = None
 
 
 class AppConfig(BaseModel):
@@ -19,7 +26,7 @@ class File(BaseModel):
 
 class Folder(BaseModel):
     name: str
-    type: Literal["folder"]
+    type: Literal["root_folder", "sub_folder"]
     items: List[Union[File, 'Folder']] = Field(default_factory=list)
 
 

folder_classifier-0.4.0/folder_classifier/util.py

@@ -0,0 +1,103 @@
+import os
+from pathlib import PurePosixPath
+from typing import List, Union
+
+from folder_classifier.dto import Folder, File
+import boto3
+
+
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gemini-2.0-flash")
+OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL", "https://openaiproxy.dev.cortoaws.com/v1")
+
+PARAM_STORE_OPENAI_API_KEY = os.getenv("PARAM_STORE_OPENAI_API_KEY", "/AiService/OpenAiSettings/ApiKey")
+AWS_REGION_NAME = os.getenv("AWS_REGION_NAME", "us-west-2")
+
+
+def get_openapi_key() -> str:
+    boto_session = boto3.Session(region_name=AWS_REGION_NAME)
+    ssm_client = boto_session.client("ssm")
+    response = ssm_client.get_parameter(Name=PARAM_STORE_OPENAI_API_KEY, WithDecryption=True)
+    return response["Parameter"]["Value"]
+
+
+def build_folder(paths: List[str]) -> Folder:
+    """
+    Create a Folder tree from a list of file paths.
+    Assumptions:
+    - The file paths are delimited by "/"
+    - There are no '.' and '..' entries in the paths
+    - The paths are case-insensitive (Windows paths) -> 'ABC' and 'abc' resolve to the same item
+    """
+    if not paths:
+        raise ValueError("No paths provided")
+
+    # Build a LOWER-CASED directory-prefix set so folder/file disambiguation is case-insensitive.
+    prefix_set_lower = set()
+    for p in paths:
+        parts = p.split('/')
+        for i in range(1, len(parts)):
+            prefix_set_lower.add('/'.join(parts[:i]).lower())
+
+    # Sort by depth so parents are created before children
+    sorted_paths = sorted(paths, key=lambda x: x.count('/'))
+
+    # Create the root folder (preserve first-seen casing)
+    root_name = sorted_paths[0].split('/')[0]
+    root = Folder(name=root_name, type="root_folder", items=[])
+
+    # Build the tree
+    for p in sorted_paths:
+        parts = p.split('/')
+        current = root
+
+        for idx, part in enumerate(parts[1:], start=1):
+            part_lower = part.lower()
+            full_path_lower = '/'.join(parts[:idx + 1]).lower()
+            is_last = idx == len(parts) - 1
+
+            # Case-insensitive lookup of existing child
+            existing = next((item for item in current.items if item.name.lower() == part_lower), None)
+            if existing:
+                if isinstance(existing, Folder):
+                    current = existing
+                continue
+
+            # Determine type for new item
+            if is_last and full_path_lower not in prefix_set_lower:
+                if part.strip() in (".", ".."):
+                    # These won't appear in the paths, ignore if they do.
+                    continue
+                has_ext = bool(PurePosixPath(part).suffix)
+                is_dotfile = part.startswith('.') and len(part) > 1
+                is_file = has_ext or is_dotfile
+                new_item = File(name=part, type="file") if is_file else Folder(name=part, type="sub_folder", items=[])
+            else:
+                new_item = Folder(name=part, type="sub_folder", items=[])
+
+            current.items.append(new_item)
+            if isinstance(new_item, Folder):
+                current = new_item
+
+    return root
+
+
+def render_tree(folder: Folder) -> str:
+    """
+    Render Folder tree using ASCII tree characters (├──, └──, │).
+    """
+    lines: List[str] = []
+
+    def recurse(node: Union[Folder, File], prefix: str, is_last: bool):
+        connector = "└── " if is_last else "├── "
+        lines.append(f"{prefix}{connector}{node.name}")
+        if isinstance(node, Folder):
+            child_prefix = prefix + ("    " if is_last else "│   ")
+            for idx, child in enumerate(node.items):
+                recurse(child, child_prefix, idx == len(node.items) - 1)
+
+    # root
+    lines.append(folder.name)
+    for idx, child in enumerate(folder.items):
+        recurse(child, "", idx == len(folder.items) - 1)
+
+    return "\n".join(lines)

{folder_classifier-0.3.8 → folder_classifier-0.4.0}/folder_classifier.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: folder-classifier
-Version: 0.3.8
+Version: 0.4.0
 Summary: Deploy folder classifier API to a Ray cluster
 Author: Crispin Almodovar
 Author-email: 

{folder_classifier-0.3.8 → folder_classifier-0.4.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = folder-classifier
-version = 0.3.8
+version = 0.4.0
 author = Crispin Almodovar
 author_email = 
 description = Deploy folder classifier API to a Ray cluster

folder_classifier-0.3.8/folder_classifier/util.py

@@ -1,95 +0,0 @@
-from typing import List, Union
-
-from folder_classifier.dto import Folder, File
-
-
-def build_folder(paths: List[str]) -> Folder:
-    """
-    Create a Folder tree from a list of file paths;
-    The file paths are delimited by "/" - leaf segments are assumed to be files
-    """
-    if not paths:
-        raise ValueError("No paths provided")
-
-    # Get all directory prefixes
-    prefix_set = set()
-    for p in paths:
-        parts = p.split('/')
-        for i in range(1, len(parts)):
-            prefix_set.add('/'.join(parts[:i]))
-
-    # Sort by depth so parents are created before children
-    sorted_paths = sorted(paths, key=lambda x: x.count('/'))
-
-    # Create root folder
-    root_name = sorted_paths[0].split('/')[0]
-    root = Folder(name=root_name, type="folder", items=[])
-
-    # Build the tree
-    for p in sorted_paths:
-        parts = p.split('/')
-        current = root
-        for idx, part in enumerate(parts[1:], start=1):
-            full_path = '/'.join(parts[:idx+1])
-            is_last = idx == len(parts) - 1
-
-            # existing item
-            existing = next((item for item in current.items if item.name == part), None)
-            if existing:
-                if isinstance(existing, Folder):
-                    current = existing
-                continue
-
-            # Determine type for new item
-            if is_last and full_path not in prefix_set:
-                new_item = File(name=part, type="file")
-            else:
-                new_item = Folder(name=part, type="folder", items=[])
-
-            current.items.append(new_item)
-            if isinstance(new_item, Folder):
-                current = new_item
-
-    return root
-
-
-def render_tree(folder: Folder) -> str:
-    """
-    Render Folder tree using ASCII tree characters (├──, └──, │).
-    """
-    lines: List[str] = []
-
-    def recurse(node: Union[Folder, File], prefix: str, is_last: bool):
-        connector = "└── " if is_last else "├── "
-        lines.append(f"{prefix}{connector}{node.name}")
-        if isinstance(node, Folder):
-            child_prefix = prefix + ("    " if is_last else "│   ")
-            for idx, child in enumerate(node.items):
-                recurse(child, child_prefix, idx == len(node.items) - 1)
-
-    # root
-    lines.append(folder.name)
-    for idx, child in enumerate(folder.items):
-        recurse(child, "", idx == len(folder.items) - 1)
-
-    return "\n".join(lines)
-
-
-def flatten_folder(folder: Folder, parent_path: str = "") -> List[str]:
-    """
-    Traverses a Folder and returns a list of file paths.
-    Each path is constructed by joining folder and file names with '/'.
-    """
-    paths: List[str] = []
-    # Build the path for the current folder
-    current_path = f"{parent_path}/{folder.name}" if parent_path else folder.name
-
-    for item in folder.items:
-        if item.type == "file":
-            paths.append(f"{current_path}/{item.name}")
-        else:
-            # Recursively flatten subfolders
-            paths.extend(flatten_folder(item, current_path))
-    return paths
-
-