Add car sharing tools and update requirements and README

CAR_SHARING_README.md

@@ -0,0 +1,87 @@
+# Car Sharing Administration Agent
+
+This agent helps with car sharing administration by tracking kilometers traveled and generating reports.
+
+## Features
+
+- Record trips with starting and ending kilometer readings
+- Calculate total kilometers traveled in a month
+- Manage multiple users
+- Parse kilometer readings from simple user input
+
+## How to Use
+
+### Recording a Trip
+
+1. Set your user name first (if not already set)
+   ```
+   Please set my name as John Doe
+   ```
+
+2. Record a starting kilometer reading
+   ```
+   61520
+   ```
+   The agent will recognize this as a starting reading.
+
+3. Record an ending kilometer reading
+   ```
+   64520
+   ```
+   The agent will calculate the distance traveled (3000 km in this example) and record the trip.
+
+4. Alternatively, provide both readings at once
+   ```
+   I drove from 61520 to 64520
+   ```
+   The agent will parse both readings and record the trip.
+
+### Getting Statistics
+
+To get your monthly statistics, ask something like:
+```
+How many kilometers did I travel this month?
+```
+or
+```
+Show me my trip summary for April 2023
+```
+
+### Managing Users
+
+You can switch between different users:
+```
+Switch to user Jane Doe
+```
+
+## Examples of Interactions
+
+**Setting user:**
+```
+User: I'm John Doe
+Agent: I've set your name as John Doe. You can now record your trips.
+```
+
+**Recording a trip:**
+```
+User: 61520
+Agent: I've recorded 61520 as your starting kilometer reading. Please provide an ending reading when your trip is complete.
+
+User: 64520
+Agent: I've recorded your trip:
+- Starting km: 61520
+- Ending km: 64520
+- Distance traveled: 3000 km
+```
+
+**Getting statistics:**
+```
+User: How many kilometers did I travel this month?
+Agent: You've traveled 3000 kilometers in May 2023 across 1 trip.
+```
+
+## Technical Notes
+
+The agent uses a SQLite database to store trip information. The database file (`car_sharing.db`) is created in the working directory.
+
+User information is stored in a JSON file (`car_sharing_users.json`) in the working directory. 

app.py

@@ -5,6 +5,12 @@ import pytz
 import yaml
 from tools.final_answer import FinalAnswerTool
 
+# Import our new car sharing tools
+from tools.record_trip_tool import RecordTripTool
+from tools.get_monthly_stats_tool import GetMonthlyStatsTool
+from tools.parse_km_reading_tool import ParseKmReadingTool
+from tools.user_management_tool import UserManagementTool
+
 from Gradio_UI import GradioUI
 
 # Below is an example of a tool that does nothing. Amaze us with your creativity !
@@ -36,6 +42,12 @@ def get_current_time_in_timezone(timezone: str) -> str:
 
 final_answer = FinalAnswerTool()
 
+# Initialize our car sharing tools
+record_trip_tool = RecordTripTool()
+get_monthly_stats_tool = GetMonthlyStatsTool()
+parse_km_reading_tool = ParseKmReadingTool()
+user_management_tool = UserManagementTool()
+
 # If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
 # model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 
 
@@ -55,7 +67,14 @@ with open("prompts.yaml", 'r') as stream:
     
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, get_current_time_in_timezone], ## add your tools here (don't remove final answer)
+    tools=[
+        final_answer, 
+        get_current_time_in_timezone,
+        record_trip_tool,
+        get_monthly_stats_tool,
+        parse_km_reading_tool,
+        user_management_tool
+    ], ## add your tools here (don't remove final answer)
     max_steps=6,
     verbosity_level=1,
     grammar=None,

requirements.txt

@@ -3,3 +3,6 @@ smolagents==1.13.0
 requests
 duckduckgo_search
 pandas
+pytz
+pyyaml
+sqlite3

tools/car_sharing_db.py

@@ -0,0 +1,128 @@
+import sqlite3
+import os
+import datetime
+from typing import List, Dict, Any, Optional, Tuple
+
+class CarSharingDB:
+    def __init__(self, db_path="car_sharing.db"):
+        """Initialize the car sharing database."""
+        self.db_path = db_path
+        self.initialize_db()
+    
+    def initialize_db(self):
+        """Create the database tables if they don't exist."""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        # Create trips table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS trips (
+            id INTEGER PRIMARY KEY,
+            user_name TEXT NOT NULL,
+            start_km INTEGER NOT NULL,
+            end_km INTEGER NOT NULL,
+            km_traveled INTEGER NOT NULL,
+            trip_date TEXT NOT NULL
+        )
+        ''')
+        
+        conn.commit()
+        conn.close()
+    
+    def record_trip(self, user_name: str, start_km: int, end_km: int) -> bool:
+        """Record a new trip in the database."""
+        try:
+            km_traveled = end_km - start_km
+            if km_traveled <= 0:
+                return False
+            
+            trip_date = datetime.datetime.now().strftime("%Y-%m-%d")
+            
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            cursor.execute(
+                "INSERT INTO trips (user_name, start_km, end_km, km_traveled, trip_date) VALUES (?, ?, ?, ?, ?)",
+                (user_name, start_km, end_km, km_traveled, trip_date)
+            )
+            
+            conn.commit()
+            conn.close()
+            return True
+        except Exception as e:
+            print(f"Error recording trip: {str(e)}")
+            return False
+    
+    def get_monthly_stats(self, user_name: str, month: Optional[int] = None, year: Optional[int] = None) -> Dict[str, Any]:
+        """Get monthly statistics for a user."""
+        try:
+            if month is None or year is None:
+                # Use current month and year if not specified
+                now = datetime.datetime.now()
+                month = now.month
+                year = now.year
+            
+            # Format date range for the specified month
+            start_date = f"{year}-{month:02d}-01"
+            
+            # Calculate the last day of the month
+            if month == 12:
+                next_month_year = year + 1
+                next_month = 1
+            else:
+                next_month_year = year
+                next_month = month + 1
+            
+            end_date = f"{next_month_year}-{next_month:02d}-01"
+            
+            conn = sqlite3.connect(self.db_path)
+            cursor = conn.cursor()
+            
+            # Get total kilometers and trip count
+            cursor.execute(
+                "SELECT SUM(km_traveled), COUNT(*) FROM trips WHERE user_name = ? AND trip_date >= ? AND trip_date < ?",
+                (user_name, start_date, end_date)
+            )
+            
+            total_km, trip_count = cursor.fetchone()
+            
+            # Get all trips in the month
+            cursor.execute(
+                "SELECT start_km, end_km, km_traveled, trip_date FROM trips WHERE user_name = ? AND trip_date >= ? AND trip_date < ? ORDER BY trip_date",
+                (user_name, start_date, end_date)
+            )
+            
+            trips = []
+            for row in cursor.fetchall():
+                trips.append({
+                    "start_km": row[0],
+                    "end_km": row[1],
+                    "km_traveled": row[2],
+                    "trip_date": row[3]
+                })
+            
+            conn.close()
+            
+            # Default to 0 if no trips found
+            total_km = total_km or 0
+            trip_count = trip_count or 0
+            
+            return {
+                "user_name": user_name,
+                "month": month,
+                "year": year,
+                "total_km": total_km,
+                "trip_count": trip_count,
+                "trips": trips
+            }
+        except Exception as e:
+            print(f"Error getting monthly stats: {str(e)}")
+            return {
+                "user_name": user_name,
+                "month": month,
+                "year": year,
+                "total_km": 0,
+                "trip_count": 0,
+                "trips": [],
+                "error": str(e)
+            } 

tools/get_monthly_stats_tool.py

@@ -0,0 +1,63 @@
+from typing import Any, Dict, Optional
+from smolagents.tools import Tool
+from tools.car_sharing_db import CarSharingDB
+
+class GetMonthlyStatsTool(Tool):
+    name = "get_monthly_stats"
+    description = "Retrieves monthly car sharing statistics for a specific user."
+    inputs = {
+        'user_name': {'type': 'string', 'description': 'Name of the user to get statistics for'},
+        'month': {'type': 'integer', 'description': 'Month number (1-12). If not provided, current month is used.'},
+        'year': {'type': 'integer', 'description': 'Year (e.g., 2023). If not provided, current year is used.'}
+    }
+    output_type = "dict"
+
+    def __init__(self, db_path="car_sharing.db"):
+        self.db = CarSharingDB(db_path)
+        self.is_initialized = True
+
+    def forward(self, user_name: str, month: Optional[int] = None, year: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Get monthly car sharing statistics for a user.
+        
+        Args:
+            user_name: Name of the user to get statistics for
+            month: Month number (1-12). If not provided, current month is used.
+            year: Year (e.g., 2023). If not provided, current year is used.
+            
+        Returns:
+            A dictionary with monthly statistics
+        """
+        try:
+            # Convert month and year to integers if provided
+            if month is not None:
+                month = int(month)
+                if month < 1 or month > 12:
+                    return {
+                        "success": False,
+                        "error": "Month must be between 1 and 12",
+                        "total_km": 0
+                    }
+            
+            if year is not None:
+                year = int(year)
+            
+            # Get monthly statistics
+            stats = self.db.get_monthly_stats(user_name, month, year)
+            
+            # Add success flag
+            stats["success"] = True
+            
+            return stats
+        except ValueError:
+            return {
+                "success": False,
+                "error": "Month and year must be integers",
+                "total_km": 0
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "total_km": 0
+            } 

tools/parse_km_reading_tool.py

@@ -0,0 +1,98 @@
+from typing import Any, Dict, Union
+from smolagents.tools import Tool
+import re
+
+class ParseKmReadingTool(Tool):
+    name = "parse_km_reading"
+    description = "Parses kilometer readings from user input."
+    inputs = {
+        'input_text': {'type': 'string', 'description': 'Text input from the user that may contain kilometer readings'}
+    }
+    output_type = "dict"
+
+    def __init__(self):
+        self.is_initialized = True
+        # Store the last valid kilometer reading to use as start_km for future trips
+        self.last_reading = None
+
+    def forward(self, input_text: str) -> Dict[str, Any]:
+        """
+        Parse kilometer readings from user input.
+        
+        Args:
+            input_text: Text input that may contain kilometer readings
+            
+        Returns:
+            A dictionary with parsed kilometer readings
+        """
+        try:
+            # Clean and normalize input
+            clean_text = input_text.strip().replace(',', '')
+            
+            # Find all numbers in the input
+            numbers = re.findall(r'\b\d+\b', clean_text)
+            numbers = [int(num) for num in numbers]
+            
+            # Determine what kind of reading this is
+            result = {
+                "success": True,
+                "numbers_found": numbers,
+                "reading_type": None
+            }
+            
+            if len(numbers) == 0:
+                result["success"] = False
+                result["error"] = "No kilometer readings found in input"
+                return result
+            
+            if len(numbers) == 1:
+                # Single reading - could be start or end
+                km_reading = numbers[0]
+                
+                if self.last_reading is None:
+                    # First reading ever, must be start
+                    result["reading_type"] = "start"
+                    result["start_km"] = km_reading
+                    self.last_reading = km_reading
+                else:
+                    # We have a previous reading
+                    if km_reading > self.last_reading:
+                        # This is likely an end reading
+                        result["reading_type"] = "end"
+                        result["end_km"] = km_reading
+                        result["start_km"] = self.last_reading
+                        result["km_traveled"] = km_reading - self.last_reading
+                        self.last_reading = km_reading
+                    else:
+                        # This is likely a new start reading
+                        result["reading_type"] = "start"
+                        result["start_km"] = km_reading
+                        self.last_reading = km_reading
+            
+            elif len(numbers) == 2:
+                # Two readings - likely start and end
+                start_km = min(numbers)
+                end_km = max(numbers)
+                
+                result["reading_type"] = "complete"
+                result["start_km"] = start_km
+                result["end_km"] = end_km
+                result["km_traveled"] = end_km - start_km
+                self.last_reading = end_km
+            
+            else:
+                # More than 2 numbers - take first and last assuming chronological order
+                result["reading_type"] = "multiple"
+                result["start_km"] = numbers[0]
+                result["end_km"] = numbers[-1]
+                result["km_traveled"] = numbers[-1] - numbers[0]
+                result["all_readings"] = numbers
+                self.last_reading = numbers[-1]
+            
+            return result
+        
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            } 

tools/record_trip_tool.py

@@ -0,0 +1,72 @@
+from typing import Any, Dict
+from smolagents.tools import Tool
+from tools.car_sharing_db import CarSharingDB
+
+class RecordTripTool(Tool):
+    name = "record_trip"
+    description = "Records a car sharing trip with starting and ending kilometer readings."
+    inputs = {
+        'user_name': {'type': 'string', 'description': 'Name of the user who made the trip'},
+        'start_km': {'type': 'integer', 'description': 'Starting kilometer reading of the vehicle'},
+        'end_km': {'type': 'integer', 'description': 'Ending kilometer reading of the vehicle'}
+    }
+    output_type = "dict"
+
+    def __init__(self, db_path="car_sharing.db"):
+        self.db = CarSharingDB(db_path)
+        self.is_initialized = True
+
+    def forward(self, user_name: str, start_km: int, end_km: int) -> Dict[str, Any]:
+        """
+        Record a car sharing trip in the database.
+        
+        Args:
+            user_name: Name of the user who made the trip
+            start_km: Starting kilometer reading
+            end_km: Ending kilometer reading
+            
+        Returns:
+            A dictionary with the result of the operation
+        """
+        try:
+            # Ensure kilometers are integers
+            start_km = int(start_km)
+            end_km = int(end_km)
+            
+            # Validate input
+            if end_km <= start_km:
+                return {
+                    "success": False,
+                    "error": "End kilometer reading must be greater than start kilometer reading",
+                    "km_traveled": 0
+                }
+            
+            # Record the trip
+            success = self.db.record_trip(user_name, start_km, end_km)
+            
+            if success:
+                return {
+                    "success": True,
+                    "user_name": user_name,
+                    "start_km": start_km,
+                    "end_km": end_km,
+                    "km_traveled": end_km - start_km
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "Failed to record trip",
+                    "km_traveled": 0
+                }
+        except ValueError:
+            return {
+                "success": False,
+                "error": "Kilometer readings must be integers",
+                "km_traveled": 0
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "km_traveled": 0
+            } 

tools/user_management_tool.py

@@ -0,0 +1,148 @@
+from typing import Any, Dict, Optional
+from smolagents.tools import Tool
+import json
+import os
+
+class UserManagementTool(Tool):
+    name = "user_management"
+    description = "Manages user information for the car sharing system."
+    inputs = {
+        'action': {'type': 'string', 'description': 'The action to perform (get, set, list)'},
+        'user_name': {'type': 'string', 'description': 'Name of the user'},
+        'user_info': {'type': 'any', 'description': 'User information to store (for set action)'}
+    }
+    output_type = "dict"
+
+    def __init__(self, users_file="car_sharing_users.json"):
+        self.is_initialized = True
+        self.users_file = users_file
+        self.users = self._load_users()
+        self.current_user = None
+    
+    def _load_users(self) -> Dict[str, Dict[str, Any]]:
+        """Load users from file or create an empty dict if file doesn't exist."""
+        if os.path.exists(self.users_file):
+            try:
+                with open(self.users_file, 'r') as f:
+                    return json.load(f)
+            except Exception:
+                return {}
+        return {}
+    
+    def _save_users(self) -> bool:
+        """Save users to file."""
+        try:
+            with open(self.users_file, 'w') as f:
+                json.dump(self.users, f, indent=2)
+            return True
+        except Exception:
+            return False
+    
+    def forward(self, action: str, user_name: Optional[str] = None, user_info: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Manage user information.
+        
+        Args:
+            action: The action to perform (get, set, list, set_current)
+            user_name: Name of the user
+            user_info: User information to store (for set action)
+            
+        Returns:
+            A dictionary with the result of the operation
+        """
+        try:
+            action = action.lower()
+            
+            if action == "list":
+                # List all users
+                return {
+                    "success": True,
+                    "action": "list",
+                    "users": list(self.users.keys()),
+                    "current_user": self.current_user
+                }
+            
+            elif action == "get":
+                # Get user info
+                if not user_name:
+                    return {
+                        "success": False,
+                        "action": "get",
+                        "error": "User name is required for 'get' action"
+                    }
+                
+                if user_name not in self.users:
+                    return {
+                        "success": False,
+                        "action": "get",
+                        "error": f"User '{user_name}' not found"
+                    }
+                
+                return {
+                    "success": True,
+                    "action": "get",
+                    "user_name": user_name,
+                    "user_info": self.users[user_name]
+                }
+            
+            elif action == "set":
+                # Set user info
+                if not user_name:
+                    return {
+                        "success": False,
+                        "action": "set",
+                        "error": "User name is required for 'set' action"
+                    }
+                
+                if user_info is None:
+                    user_info = {}
+                
+                # Create or update user
+                if user_name in self.users:
+                    self.users[user_name].update(user_info)
+                else:
+                    self.users[user_name] = user_info
+                
+                self._save_users()
+                
+                return {
+                    "success": True,
+                    "action": "set",
+                    "user_name": user_name,
+                    "user_info": self.users[user_name]
+                }
+            
+            elif action == "set_current":
+                # Set current user
+                if not user_name:
+                    return {
+                        "success": False,
+                        "action": "set_current",
+                        "error": "User name is required for 'set_current' action"
+                    }
+                
+                # Create user if it doesn't exist
+                if user_name not in self.users:
+                    self.users[user_name] = {}
+                    self._save_users()
+                
+                self.current_user = user_name
+                
+                return {
+                    "success": True,
+                    "action": "set_current",
+                    "user_name": user_name,
+                    "current_user": self.current_user
+                }
+            
+            else:
+                return {
+                    "success": False,
+                    "error": f"Unknown action: {action}"
+                }
+        
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }