testing

.gitattributes copy

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,18 @@
+.idea/
+.vscode/
+.venv*/
+venv*/
+__pycache__/
+dist/
+.coverage*
+htmlcov/
+.tox/
+docs/_build/
+*.pkl
+*.pyc
+__pycache__/
+venv/
+.env
+instance/
+*.sqlite3
+.vercel

Dockerfile

@@ -0,0 +1,14 @@
+# Use the official Python 3.10.9 image
+FROM python:3.10.9
+
+# Copy the current directory contents into the container at .
+COPY . .
+
+# Set the working directory to /
+WORKDIR /
+
+# Install requirements.txt 
+RUN pip install --no-cache-dir --upgrade -r /requirements.txt
+
+# Start the FastAPI app on port 7860, the default port expected by Spaces
+CMD ["python", "app.py"]

README copy.md

@@ -0,0 +1,72 @@
+---
+title: Rainwater Harvesting Recommendation System
+emoji: 🌧️
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+---
+
+# Rainwater Harvesting Recommendation System
+
+This is a FastAPI-based microservice that provides rainwater harvesting recommendations based on location, roof area, and other parameters.
+
+## Features
+
+- **Rainfall Prediction**: Uses machine learning to predict rainfall for specific locations and dates
+- **Rooftop Calculation**: Calculates potential rainwater harvesting capacity based on roof area and local conditions
+- **Structure Recommendations**: Suggests appropriate rainwater harvesting structures based on available space and groundwater levels
+- **Cost Analysis**: Provides cost estimates and ROI calculations for rainwater harvesting systems
+
+## API Endpoints
+
+### POST `/api/roofTopCalculation`
+
+Calculate rainwater harvesting parameters for a given location and roof specifications.
+
+**Request Body:**
+```json
+{
+  "location": "Karur",
+  "roof_area": 100,
+  "open_space": 50,
+  "roof_type": "concrete",
+  "dwellers": 4
+}
+```
+
+**Response:**
+Returns detailed calculations including:
+- Runoff volume calculations
+- Harvestable water estimates
+- Structure recommendations
+- Cost analysis
+- Feasibility scores
+
+## Technology Stack
+
+- **FastAPI**: Web framework
+- **Pandas**: Data manipulation
+- **Scikit-learn**: Machine learning predictions
+- **Hugging Face Hub**: Model and data hosting
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+```bash
+python app.py
+```
+
+The API will be available at `http://localhost:10000`
+
+## Docker
+
+```bash
+docker build -t rainwater-harvesting .
+docker run -p 10000:10000 rainwater-harvesting
+```

RainFallModel.py

@@ -0,0 +1,62 @@
+
+import os
+import pandas as pd
+import numpy as np
+from huggingface_hub import hf_hub_download
+
+repo_id = "Navanihk/rainfallPrediction"
+cache_dir = '/tmp/hf_cache'
+os.makedirs(cache_dir, exist_ok=True)
+csv_path = hf_hub_download(repo_id=repo_id, filename="rainFallData.csv", cache_dir=cache_dir,
+                       
+                           )
+        # Load as DataFrame
+df= pd.read_csv(csv_path, sep=";")
+#  df= pd.read_csv('./rainFallData.csv',sep=";")
+import calendar
+print(df)
+# Function to remove invalid days for each month
+def valid_day(row):
+    year = 2025
+    month = row['month']
+    day = row['day']
+    max_day = calendar.monthrange(year, month)[1]  # max days in the month
+    return day <= max_day
+def calculate_rainfall():
+    # Debug: Print actual column names
+    print("Available columns in DataFrame:", df.columns.tolist())
+    print("DataFrame shape:", df.shape)
+    print("First few rows:")
+    print(df.head())
+    
+    # Check if required columns exist
+    required_cols = ['state', 'district', 'month']
+    missing_cols = [col for col in required_cols if col not in df.columns]
+    
+    if missing_cols:
+        print(f"ERROR: Missing columns: {missing_cols}")
+        print("Please check the actual column names in your CSV file")
+        return None
+    
+    # Melt to long format
+    day_cols = [col for col in df.columns if col not in ['state', 'district', 'month']]
+    df_long = df.melt(
+        id_vars=["state", "district", "month"],
+        value_vars=day_cols,
+        var_name="day",
+        value_name="rainfall"
+    )
+
+    # Extract numeric day
+    df_long['day'] = df_long['day'].str.extract(r'(\d+)').astype(int)
+
+    # Keep only valid days
+    df_long = df_long[df_long.apply(valid_day, axis=1)]
+
+    # Create proper date
+    df_long['date'] = pd.to_datetime(
+        dict(year=2025, month=df_long['month'], day=df_long['day'])
+    )
+
+    df_long = df_long.sort_values(['district', 'date']).reset_index(drop=True)
+    return df_long

RoofTopCalculation.py

@@ -0,0 +1,285 @@
+import math
+import os
+import pickle
+import pandas as pd
+from huggingface_hub import hf_hub_download
+
+repo_id = "Navanihk/rainfallPrediction"
+cache_dir = '/tmp/hf_cache'
+os.makedirs(cache_dir, exist_ok=True)
+def predict_rainfall_for_date(df_long, model, district_name, target_date, lags=7):
+    """
+    Predict rainfall for a specific district and date.
+
+    df_long: original dataset (with columns ['district','state','date','rainfall'])
+    model: trained LightGBM model
+    district_name: name of the district to predict
+    target_date: pd.Timestamp or string in 'YYYY-MM-DD'
+    lags: number of lag days to use
+    """
+    
+
+    # Ensure target_date is Timestamp
+    target_date = pd.Timestamp(target_date)
+
+    # Get district data up to the day before target_date
+    district_data = df_long[(df_long['district']==district_name) &
+                            (df_long['date'] < target_date)].sort_values('date')
+
+    # Check if enough data for lags
+    if len(district_data) < lags:
+        raise ValueError(f"Not enough data to create {lags} lag features for {district_name}")
+
+    # Get last 'lags' days of rainfall (most recent first)
+    lag_values = list(district_data['rainfall'].tail(lags).values[::-1])
+
+    # Create feature vector: lag + date features
+    features = lag_values + [target_date.month, target_date.day, target_date.dayofyear]
+
+    # Predict
+    pred_rain = model.predict([features])[0]
+
+    return {
+        'district': district_name,
+        'state': district_data['state'].iloc[0],
+        'date': target_date,
+        'predicted_rainfall': pred_rain
+    }
+
+
+
+def rainFallPrediction(location,RainFallData):
+    """Predict average annual rainfall for a given location using RainFallData"""
+    model_path = hf_hub_download(repo_id=repo_id, filename="rainfall.pkl", cache_dir=cache_dir,
+                            
+                                  )
+    
+    # Load the actual model from the downloaded file
+    with open(model_path, 'rb') as f:
+        model = pickle.load(f)
+    
+    # model = pickle.load(open('rainfall.pkl','rb'))
+    date = "2025-01-10"
+    print("predict_rainfall_for_date called")
+
+    pred_result = predict_rainfall_for_date(RainFallData, model, location, date)
+    print(pred_result)
+    return pred_result['predicted_rainfall'] # Default to Delhi-like rainfall if location not found
+def RooftTopCalculation(input_data,RainFallData):
+    """
+    Calculate rainwater harvesting parameters based on input data
+    """
+    # Extract input parameters
+    location = input_data.get('location', 'Unknown')
+    roof_area = input_data.get('roof_area', 0)
+    open_space = input_data.get('open_space', 0)
+    roof_type = input_data.get('roof_type', 'null')
+    dwellers = input_data.get('dwellers', 1)
+    
+   
+    # Default values for calculations (these would typically come from ML models or databases)
+    # Using Delhi-like values as defaults
+    default_rainfall =  rainFallPrediction(location,RainFallData)  # mm/year
+    default_runoff_coefficient = 0.8  # typical for concrete/tiled roofs
+    groundwater_level = 15  # meters below ground level
+    soil_type = "Loamy"
+    aquifer_type = "Alluvial Aquifer"
+    
+    # Get coordinates (default to Delhi coordinates if location not found)
+    coordinates = get_coordinates(location)
+    
+    # Calculate runoff volume (in liters/year)
+    runoff_volume = roof_area * default_rainfall * default_runoff_coefficient
+    
+    # Calculate harvestable water (considering losses - typically 15-20% loss)
+    loss_factor = 0.15
+    harvestable_water = int(runoff_volume * (1 - loss_factor))
+    
+    # Calculate recharge potential (typically 60-70% of harvestable water)
+    recharge_potential = int(harvestable_water * 0.65)
+    
+    # Determine structure suggestion based on available space and groundwater level
+    structure_suggestion = determine_structure(open_space, groundwater_level, roof_area)
+    
+    # Calculate recommended dimensions
+    dimensions = calculate_dimensions(structure_suggestion, harvestable_water)
+    
+    # Calculate capacity
+    capacity = dimensions['length'] * dimensions['width'] * dimensions['depth'] * 1000  # in liters
+    
+    # Cost analysis
+    estimated_cost = calculate_cost(structure_suggestion, dimensions, roof_area)
+    water_saved_value = calculate_water_savings(harvestable_water)
+    roi_years = round(estimated_cost / water_saved_value, 1) if water_saved_value > 0 else 0
+    
+    # Feasibility score
+    feasibility_score = calculate_feasibility(roof_area, open_space, groundwater_level)
+    
+    # Prepare response
+    response = {
+        "user": {
+            "name": "User",  # Default name as not provided in input
+            "location": {
+                "lat": coordinates[0],
+                "lon": coordinates[1],
+                "address": location
+            },
+            "roof_area": roof_area,
+            "open_space": open_space,
+            "dwellers": dwellers
+        },
+        "reference_data": {
+            "rainfall": f"{default_rainfall} mm/year",
+            "aquifer": aquifer_type,
+            "groundwater_level": f"{groundwater_level} m bgl",
+            "soil_type": soil_type,
+            "runoff_coefficient": default_runoff_coefficient
+        },
+        "calculations": {
+            "runoff_volume": f"{int(runoff_volume)} liters/year",
+            "harvestable_water": f"{harvestable_water} liters/year",
+            "recharge_potential": f"{recharge_potential} liters/year",
+            "structure_suggestion": structure_suggestion,
+            "recommended_dimensions": dimensions,
+            "capacity": f"{int(capacity)} liters"
+        },
+        "cost_analysis": {
+            "estimated_cost": f"₹{estimated_cost:,}",
+            "water_saved_value": f"₹{int(water_saved_value):,}/year",
+            "roi": f"{roi_years} years"
+        },
+        "gis_data": {
+            "map_coordinates": coordinates,
+            "feasibility_score": feasibility_score
+        },
+        "support": {
+            "regional_language": get_regional_language(location),
+            "faq_link": "https://cgwb.gov.in/rtrwh-faqs"
+        }
+    }
+    
+    return response
+
+def get_coordinates(location):
+    """Get coordinates for a location (simplified - would use geocoding service in production)"""
+    location_coordinates = {
+        "karur": [10.9601, 78.0766],
+        "new delhi": [28.6139, 77.2090],
+        "delhi": [28.6139, 77.2090],
+        "mumbai": [19.0760, 72.8777],
+        "bangalore": [12.9716, 77.5946],
+        "chennai": [13.0827, 80.2707],
+        "hyderabad": [17.3850, 78.4867],
+        "pune": [18.5204, 73.8567],
+        "kolkata": [22.5726, 88.3639],
+        "ahmedabad": [23.0225, 72.5714],
+        "jaipur": [26.9124, 75.7873]
+    }
+    
+    location_lower = location.lower()
+    return location_coordinates.get(location_lower, [28.6139, 77.2090])  # Default to Delhi
+
+def determine_structure(open_space, groundwater_level, roof_area):
+    """Determine the best rainwater harvesting structure"""
+    if open_space >= 100 and groundwater_level > 10:
+        return "Recharge Pit"
+    elif open_space >= 50 and groundwater_level > 5:
+        return "Percolation Tank"
+    elif roof_area >= 100:
+        return "Storage Tank"
+    else:
+        return "Rain Barrel"
+
+def calculate_dimensions(structure_type, harvestable_water):
+    """Calculate recommended dimensions based on structure type"""
+    if structure_type == "Recharge Pit":
+        # Calculate based on recharge requirements
+        volume_needed = harvestable_water / 1000  # Convert to cubic meters
+        depth = min(3, max(2, volume_needed / 4))  # Depth between 2-3m
+        area_needed = volume_needed / depth
+        side = math.sqrt(area_needed)
+        return {
+            "length": round(side, 1),
+            "width": round(side, 1),
+            "depth": round(depth, 1)
+        }
+    elif structure_type == "Percolation Tank":
+        return {"length": 3.0, "width": 3.0, "depth": 2.0}
+    elif structure_type == "Storage Tank":
+        return {"length": 2.0, "width": 2.0, "depth": 2.5}
+    else:  # Rain Barrel
+        return {"length": 1.0, "width": 1.0, "depth": 1.5}
+
+def calculate_cost(structure_type, dimensions, roof_area):
+    """Calculate estimated cost in INR"""
+    base_costs = {
+        "Recharge Pit": 15000,
+        "Percolation Tank": 25000,
+        "Storage Tank": 20000,
+        "Rain Barrel": 5000
+    }
+    
+    base_cost = base_costs.get(structure_type, 15000)
+    volume = dimensions['length'] * dimensions['width'] * dimensions['depth']
+    
+    # Additional cost based on volume and roof area
+    additional_cost = (volume * 2000) + (roof_area * 50)
+    
+    return int(base_cost + additional_cost)
+
+def calculate_water_savings(harvestable_water):
+    """Calculate annual water savings value in INR"""
+    # Assuming water cost of ₹12 per 1000 liters
+    water_cost_per_1000_liters = 12
+    annual_savings = (harvestable_water / 1000) * water_cost_per_1000_liters
+    return annual_savings
+
+def calculate_feasibility(roof_area, open_space, groundwater_level):
+    """Calculate feasibility score"""
+    score = 0
+    
+    if roof_area >= 100:
+        score += 30
+    elif roof_area >= 50:
+        score += 20
+    else:
+        score += 10
+        
+    if open_space >= 100:
+        score += 30
+    elif open_space >= 50:
+        score += 20
+    else:
+        score += 10
+        
+    if groundwater_level > 10:
+        score += 40
+    elif groundwater_level > 5:
+        score += 30
+    else:
+        score += 20
+    
+    if score >= 80:
+        return "High"
+    elif score >= 60:
+        return "Medium"
+    else:
+        return "Low"
+
+def get_regional_language(location):
+    """Get regional language based on location"""
+    language_map = {
+        "karur": "Tamil",
+        "new delhi": "Hindi",
+        "delhi": "Hindi",
+        "mumbai": "Marathi",
+        "bangalore": "Kannada",
+        "chennai": "Tamil",
+        "hyderabad": "Telugu",
+        "pune": "Marathi",
+        "kolkata": "Bengali",
+        "ahmedabad": "Gujarati",
+        "jaipur": "Hindi"
+    }
+    
+    return language_map.get(location.lower(), "Hindi")

app.py

@@ -0,0 +1,40 @@
+# app.py
+
+# from flask import Flask,request,jsonify
+# from flask_cors import CORS
+# app = Flask(__name__)
+# cors = CORS(app, resources={r"*": {"origins": "*"}})
+from fastapi import FastAPI
+import uvicorn
+
+
+# loading the data from the csv file to apandas dataframe
+app = FastAPI()
+from huggingface_hub import login
+
+from RoofTopCalculation import RooftTopCalculation
+from RainFallModel import calculate_rainfall
+
+import os
+cache_dir = '/tmp/hf_cache'
+os.makedirs(cache_dir, exist_ok=True)
+
+@app.post('/api/roofTopCalculation')
+def roof_top_calculation(data: dict):
+    RainFallData = calculate_rainfall()
+    try:
+        if not data:
+            return {"error": "No data provided"}, 400
+
+        # Perform roof top calculation logic
+        result = RooftTopCalculation(data,RainFallData)
+        return result
+
+    except Exception as e:
+        return {"error": str(e)}, 500
+
+# Run the app if the script is executed directly
+# if __name__ == '__main__':
+#     app.run(host='0.0.0.0', port=8000, debug=True)
+if __name__ == "__main__":
+    uvicorn.run(app, port=10000)

vercel.json

@@ -0,0 +1,15 @@
+{
+    "version": 2,
+    "builds": [
+        {
+            "src": "./main.py",
+            "use": "@vercel/python"
+        }
+    ],
+    "routes": [
+        {
+            "src": "/(.*)",
+            "dest": "/"
+        }
+    ]
+}