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

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

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

{folder_classifier-0.3.7 → 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.7 → folder_classifier-0.4.0}/folder_classifier/classifier.py

@@ -1,31 +1,37 @@
 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".
 """.strip()
 
 USER_PROMPT_TEMPLATE = r"""
-Task: Classify the folder tree as 'matter' or 'other'.
+Task: Classify the root folder as 'matter' or 'other'.
 
 Decision rules (apply in order):
 1) If there are no files with extension anywhere in the tree , classify as 'other'. 
 2) If the root folder appears to be a container of multiple matters , classify as 'other'.
-3)  If the root folder is or ends with a common subfolder name or descriptor found inside legal matters (e.g.,"Email", "Summons" "Emails", "Documents", "Correspondence", "Drafts", "Pleadings", "Court Documents", "Billing", or similar descriptive folder types), classify as 'other' even if it contains legal documents.
-
-4) If the root folder name matches any Matter Folder Naming Pattern and there is at least one file with an extension anywhere in the tree (including subfolders), and there is at least one file, subfolder, or filename that directly and unambiguously references a legal, client-matter, or professional context—for example, a legal document type, an initial or core legal document, clear legal terminology, a jurisdiction/court reference, the name of a law firm or legal/financial professional, or an activity specific to legal work—classify as 'matter'.
+3) If the root folder is or ends with a common subfolder name or descriptor found inside legal matters (e.g.,"Email", "Summons" "Emails", "Documents", "Correspondence", "Drafts", "Pleadings", "Court Documents", "Billing", or similar descriptive folder types), classify as 'other' even if it contains legal documents.
+4) If the root folder is a subfolder of a matter, classify as other
+5) If the root folder name matches any Matter Folder Naming Pattern and there is at least one file with an extension anywhere in the tree (including subfolders), and there is at least one file, subfolder, or filename that directly and unambiguously references a legal, client-matter, or professional context—for example, a legal document type, an initial or core legal document, clear legal terminology, a jurisdiction/court reference, the name of a law firm or legal/financial professional, or an activity specific to legal work—classify as 'matter'.
 Do not classify as 'matter' if the folder only contains general business documents (e.g., invoices, estimates, generic correspondence) and there are no strong indicators of legal, client, or matter-related content as defined above
-5) If the root folder name very compellingly looks like a matter folder e.g (11206 - AcmeX Pty v Acme Corp), classify as 'matter' even if the documents are not initial/core/legal documents.
-6) If none of the above apply, classify as 'other'.
+6) If the root folder name very compellingly looks like a matter folder e.g (11206 - AcmeX Pty v Acme Corp), classify as 'matter' even if the documents are not initial/core/legal documents.
+7) If none of the above apply, classify as 'other'.
 
 Matter Folder Naming Patterns (case-insensitive; separators like space, hyphen, underscore are fine):
 • Matter number alone or combined with a client/surname/company (e.g., "12345", "12345 Smith", "Smith - Contract Dispute").
@@ -69,7 +75,8 @@ Definitions/assumptions:
 
 Output format (JSON only, no extra text):
 {"category": "<matter|other>", "reasoning": "<1–2 short explanation referencing the key rule(s) that decided it>"}
-
+ROOT FOLDER:
+{root_folder}
 FOLDER TREE:
 {folder_tree}
 """.strip()
@@ -79,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)
@@ -101,18 +115,32 @@ 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)
+        root_folder = folder.name
         folder_tree = render_tree(folder)
         chat_completion_request = {
             "model": self.model,
             "messages": [
                 {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": USER_PROMPT_TEMPLATE.replace("{folder_tree}", folder_tree)}
+                {"role": "user", "content": USER_PROMPT_TEMPLATE.
+                                                replace("{root_folder}", root_folder).
+                                                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.7 → 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.7 → 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.7 → 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.7
+Version: 0.4.0
 Summary: Deploy folder classifier API to a Ray cluster
 Author: Crispin Almodovar
 Author-email: 

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

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

folder_classifier-0.3.7/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
-
-