chore: ruff linter and formatter (#173)

* add ruff linter and formater

Author: alfredfrancis

.github/workflows/evaluate-backend.yml

@@ -22,7 +22,11 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install -r requirements.txt
+          pip install ruff
 
+      - name: Run Ruff
+        run: ruff check --output-format=github .
+        
       - name: Test with pytest
         run: |
           pip install pytest pytest-cov

.gitignore

@@ -8,4 +8,6 @@ env/
 .DS_Store
 .pytest_cache/
 .vscode
-model_files/
+model_files/
+.ruff_cache/
+.idea/

.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    # Ruff version.
+    rev: v0.9.2
+    hooks:
+      # Run the linter.
+      - id: ruff
+      # Run the formatter.
+      - id: ruff-format

app/admin/bots/routes.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, HTTPException, UploadFile, File
+from fastapi import APIRouter, UploadFile, File
 from fastapi.responses import Response
 from typing import Dict, Any
 import json
@@ -7,20 +7,23 @@
 
 router = APIRouter(prefix="/bots")
 
+
 @router.put("/{name}/config")
 async def set_config(name: str, config: Dict[str, Any]):
     """
     Update bot config
     """
     return await store.update_config(name, config)
 
+
 @router.get("/{name}/config")
 async def get_config(name: str):
     """
     Get bot config
     """
     return await store.get_config(name)
 
+
 @router.get("/{name}/export")
 async def export_bot(name: str):
     """
@@ -29,10 +32,11 @@ async def export_bot(name: str):
     data = await store.export_bot(name)
     return Response(
         content=json.dumps(data),
-        media_type='application/json',
-        headers={'Content-Disposition': 'attachment;filename=chatbot_data.json'}
+        media_type="application/json",
+        headers={"Content-Disposition": "attachment;filename=chatbot_data.json"},
     )
 
+
 @router.post("/{name}/import")
 async def import_bot(name: str, file: UploadFile = File(...)):
     """
@@ -42,4 +46,4 @@ async def import_bot(name: str, file: UploadFile = File(...)):
     content = await file.read()
     json_data = json.loads(content)
 
-    return await store.import_bot(name, json_data)
+    return await store.import_bot(name, json_data)

app/admin/bots/schemas.py

@@ -2,11 +2,13 @@
 from typing import Dict, Any
 from app.database import ObjectIdField
 
+
 class Bot(BaseModel):
     """Base schema for bot"""
+
     id: ObjectIdField = Field(validation_alias="_id", default=None)
     name: str
     config: Dict[str, Any] = {}
 
     class Config:
-        arbitrary_types_allowed=True
+        arbitrary_types_allowed = True

app/admin/bots/store.py

@@ -6,34 +6,40 @@
 
 bot_collection = database.get_collection("bot")
 
+
 async def add_bot(data: dict):
     await bot_collection.insert_one(data)
 
+
 async def get_bot(name: str) -> Bot:
     bot = await bot_collection.find_one({"name": name})
     return Bot.model_validate(bot)
 
+
 async def get_config(name: str) -> Dict:
     bot = await get_bot(name)
     return bot.config
 
+
 async def update_config(name: str, entity_data: dict):
     await bot_collection.update_one({"name": name}, {"$set": {"config": entity_data}})
 
+
 async def export_bot(name) -> Dict:
     # Get all intents and entities
     intents = await list_intents()
     entities = await list_entities()
 
     entities = [entity.model_dump(exclude={"id"}) for entity in entities]
-    intents = [intent.model_dump(exclude={"id": True, "parameters": {'__all__': {"id"}}})  for intent in intents]
+    intents = [
+        intent.model_dump(exclude={"id": True, "parameters": {"__all__": {"id"}}})
+        for intent in intents
+    ]
 
-    export_data = {
-        "intents": intents,
-        "entities": entities
-    }
+    export_data = {"intents": intents, "entities": entities}
     return export_data
 
+
 async def import_bot(name: str, data: Dict):
     intents = data.get("intents", [])
     entities = data.get("entities", [])
@@ -43,6 +49,5 @@ async def import_bot(name: str, data: Dict):
 
     return {
         "num_intents_created": len(created_intents),
-        "num_entities_created": len(created_entities)
+        "num_entities_created": len(created_entities),
     }
-

app/admin/entities/routes.py

@@ -2,7 +2,8 @@
 from app.admin.entities import store
 from app.admin.entities.schemas import Entity
 
-router = APIRouter(prefix='/entities')
+router = APIRouter(prefix="/entities")
+
 
 @router.post("/")
 async def create_entity(entity: Entity):
@@ -11,25 +12,29 @@ async def create_entity(entity: Entity):
     entity = await store.add_entity(entity_dict)
     return entity
 
+
 @router.get("/")
 async def read_entities():
     """Get all entities"""
-    return  await store.list_entities()
+    return await store.list_entities()
+
 
 @router.get("/{entity_id}")
 async def read_entity(entity_id: str):
     """Get a specific entity by ID"""
     return await store.get_entity(entity_id)
 
+
 @router.put("/{entity_id}")
 async def update_entity(entity_id: str, entity: Entity):
     """Update an entity"""
     entity_dict = entity.model_dump(exclude={"id"})
     await store.edit_entity(entity_id, entity_dict)
     return {"status": "success"}
 
+
 @router.delete("/{entity_id}")
 async def delete_entity(entity_id: str):
     """Delete an entity"""
     await store.delete_entity(entity_id)
-    return {"status": "success"}
+    return {"status": "success"}

app/admin/entities/schemas.py

@@ -2,16 +2,20 @@
 from typing import List
 from app.database import ObjectIdField
 
+
 class EntityValue(BaseModel):
     """Schema for entity value"""
+
     value: str
     synonyms: List[str] = []
 
+
 class Entity(BaseModel):
     """Schema for entity"""
+
     id: ObjectIdField = Field(validation_alias="_id", default=None)
     name: str
     entity_values: List[EntityValue] = []
 
     class Config:
-        arbitrary_types_allowed=True
+        arbitrary_types_allowed = True

app/admin/entities/store.py

@@ -7,26 +7,34 @@
 
 entity_collection = database.get_collection("entity")
 
+
 async def add_entity(entity_data: dict) -> Entity:
     result = await entity_collection.insert_one(entity_data)
     return await get_entity(str(result.inserted_id))
 
+
 async def get_entity(id: str) -> Entity:
     entity = await entity_collection.find_one({"_id": ObjectId(id)})
     return Entity.model_validate(entity)
 
+
 async def list_entities() -> List[Entity]:
     entities = await entity_collection.find().to_list()
     return [Entity.model_validate(entity) for entity in entities]
 
+
 async def edit_entity(entity_id: str, entity_data: dict):
-    await entity_collection.update_one({"_id": ObjectId(entity_id)}, {"$set": entity_data})
+    await entity_collection.update_one(
+        {"_id": ObjectId(entity_id)}, {"$set": entity_data}
+    )
+
 
 async def delete_entity(entity_id: str):
     await entity_collection.delete_one({"_id": ObjectId(entity_id)})
 
+
 async def list_synonyms():
-    """ list all synonyms across the entities"""
+    """list all synonyms across the entities"""
     synonyms = {}
 
     entities = await list_entities()
@@ -36,14 +44,13 @@ async def list_synonyms():
                 synonyms[synonym] = value.value
     return synonyms
 
+
 async def bulk_import_entities(entities: List[Dict]) -> List[str]:
     created_entities = []
     if entities:
         for entity in entities:
             result = await entity_collection.update_one(
-                {"name": entity.get("name")}, 
-                {"$set": entity},
-                upsert=True
+                {"name": entity.get("name")}, {"$set": entity}, upsert=True
             )
             if result.upserted_id:
                 created_entities.append(str(result.upserted_id))

app/admin/intents/routes.py

@@ -2,7 +2,8 @@
 from app.admin.intents import store
 from app.admin.intents.schemas import Intent
 
-router = APIRouter(prefix='/intents')
+router = APIRouter(prefix="/intents")
+
 
 @router.post("/")
 async def create_intent(intent: Intent):
@@ -11,26 +12,30 @@ async def create_intent(intent: Intent):
     intent = await store.add_intent(intent_dict)
     return intent
 
+
 @router.get("/")
 async def read_intents():
     """Get all intents"""
     return await store.list_intents()
 
+
 @router.get("/{intent_id}")
 async def read_intent(intent_id: str):
     """Get a specific intent by ID"""
     intent = await store.get_intent(intent_id)
     return intent
 
+
 @router.put("/{intent_id}")
 async def update_intent(intent_id: str, intent: Intent):
     """Update an intent"""
     intent_dict = intent.model_dump(exclude={"id"})
     await store.edit_intent(intent_id, intent_dict)
     return {"status": "success"}
 
+
 @router.delete("/{intent_id}")
 async def delete_intent(intent_id: str):
     """Delete an intent"""
     await store.delete_intent(intent_id)
-    return {"status": "success"} 
+    return {"status": "success"}