smartfleet-optimizer 0.1.0__tar.gz

smartfleet_optimizer-0.1.0/LICENSE

@@ -0,0 +1,4 @@
+MIT License
+Copyright (c) 2025 Satvik T M
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software to deal in the Software without restriction.

smartfleet_optimizer-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: smartfleet-optimizer
+Version: 0.1.0
+Summary: Analytics library for fleet telemetry: risk scoring, alerts, maintenance prediction
+Author: Satvik T M
+Author-email: satvikw007@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# fleet-optimization-engine-satvik25159712
+
+Analytics library for fleet telemetry data. Provides risk scoring,
+alert detection, fuel efficiency analysis and maintenance prediction.
+
+## Install
+pip install fleet-optimization-engine-satvik25159712
+
+## Quick start
+from fleet_optimization_pkg import TelemetryAnalyzer
+analyzer = TelemetryAnalyzer()
+profile = analyzer.build_risk_profile({
+    "vehicle_id": "VAN-001", "speed_kmh": 50,
+    "fuel_percent": 75, "engine_temp_c": 85
+})
+print(profile.risk_label)

smartfleet_optimizer-0.1.0/README.md

@@ -0,0 +1,16 @@
+# fleet-optimization-engine-satvik25159712
+
+Analytics library for fleet telemetry data. Provides risk scoring,
+alert detection, fuel efficiency analysis and maintenance prediction.
+
+## Install
+pip install fleet-optimization-engine-satvik25159712
+
+## Quick start
+from fleet_optimization_pkg import TelemetryAnalyzer
+analyzer = TelemetryAnalyzer()
+profile = analyzer.build_risk_profile({
+    "vehicle_id": "VAN-001", "speed_kmh": 50,
+    "fuel_percent": 75, "engine_temp_c": 85
+})
+print(profile.risk_label)

smartfleet_optimizer-0.1.0/fleet_optimization_pkg/__init__.py

@@ -0,0 +1,5 @@
+from .analyzer import TelemetryAnalyzer
+from .models import AlertSeverity, FleetAlert, VehicleRiskProfile
+
+__version__ = "0.1.0"
+__all__ = ["TelemetryAnalyzer", "AlertSeverity", "FleetAlert", "VehicleRiskProfile"]

smartfleet_optimizer-0.1.0/fleet_optimization_pkg/analyzer.py

@@ -0,0 +1,156 @@
+"""
+analyzer.py
+Stateless analytics engine for fleet telemetry data.
+Called by the Lambda function each time a telemetry reading
+arrives from SQS. 
+"""
+from .models import AlertSeverity, FleetAlert, VehicleRiskProfile
+
+# Thresholds
+ENGINE_TEMP_WARNING  = 100.0
+ENGINE_TEMP_CRITICAL = 110.0
+FUEL_WARNING         = 20.0
+FUEL_CRITICAL        = 10.0
+SPEED_WARNING        = 100.0
+SPEED_CRITICAL       = 110.0
+MAINTENANCE_TEMP     = 95.0
+MAINTENANCE_FUEL     = 25.0
+
+
+class TelemetryAnalyzer:
+    """
+    Processes raw telemetry dicts into structured risk assessments.
+
+    All methods are stateless so this class is safe for use in
+    AWS Lambda which may create new instances at any time.
+    """
+
+    def build_risk_profile(self, reading):
+        """
+        Main method. Runs all analyses and returns a VehicleRiskProfile.
+        """
+        return VehicleRiskProfile(
+            vehicle_id            = reading.get("vehicle_id", "UNKNOWN"),
+            risk_score            = self.calculate_risk_score(reading),
+            alerts                = self.detect_alerts(reading),
+            fuel_efficiency_score = self.calculate_fuel_efficiency_score(reading),
+            maintenance_due       = self.predict_maintenance_needed(reading),
+        )
+
+    def calculate_risk_score(self, reading):
+        """
+        Weighted composite risk score 0-100.
+        Returns (float) Score in range 0.0 to 100.0
+        """
+        temp  = reading.get("engine_temp_c", 80.0)
+        fuel  = reading.get("fuel_percent",  100.0)
+        speed = reading.get("speed_kmh",     0.0)
+
+        # Engine temperature component
+        if temp >= ENGINE_TEMP_CRITICAL:
+            temp_risk = 100.0
+        elif temp >= ENGINE_TEMP_WARNING:
+            temp_risk = ((temp - ENGINE_TEMP_WARNING) /
+                         (ENGINE_TEMP_CRITICAL - ENGINE_TEMP_WARNING)) * 100
+        else:
+            temp_risk = 0.0
+
+        # Fuel component, low fuel = high risk
+        if fuel <= FUEL_CRITICAL:
+            fuel_risk = 100.0
+        elif fuel <= FUEL_WARNING:
+            fuel_risk = ((FUEL_WARNING - fuel) /
+                         (FUEL_WARNING - FUEL_CRITICAL)) * 100
+        else:
+            fuel_risk = 0.0
+
+        # Speed component
+        if speed >= SPEED_CRITICAL:
+            speed_risk = 100.0
+        elif speed >= SPEED_WARNING:
+            speed_risk = ((speed - SPEED_WARNING) /
+                          (SPEED_CRITICAL - SPEED_WARNING)) * 100
+        else:
+            speed_risk = 0.0
+
+        return round(min(100.0, (temp_risk  * 0.4) +
+                                (fuel_risk  * 0.3) +
+                                (speed_risk * 0.3)), 2)
+
+    def detect_alerts(self, reading):
+        """
+        Check all thresholds and return a list of FleetAlert objects.
+        """
+        alerts = []
+        vid   = reading.get("vehicle_id", "UNKNOWN")
+        temp  = reading.get("engine_temp_c", 80.0)
+        fuel  = reading.get("fuel_percent",  100.0)
+        speed = reading.get("speed_kmh",     0.0)
+
+        # Engine temperature checks
+        if temp >= ENGINE_TEMP_CRITICAL:
+            alerts.append(FleetAlert(
+                vid, "HIGH_ENGINE_TEMP", AlertSeverity.CRITICAL,
+                f"Engine temp {temp:.1f}C is critical — stop vehicle immediately.",
+                temp, ENGINE_TEMP_CRITICAL))
+        elif temp >= ENGINE_TEMP_WARNING:
+            alerts.append(FleetAlert(
+                vid, "HIGH_ENGINE_TEMP", AlertSeverity.WARNING,
+                f"Engine temp {temp:.1f}C exceeds warning threshold.",
+                temp, ENGINE_TEMP_WARNING))
+
+        # Fuel level checks
+        if fuel <= FUEL_CRITICAL:
+            alerts.append(FleetAlert(
+                vid, "LOW_FUEL", AlertSeverity.CRITICAL,
+                f"Fuel critically low at {fuel:.1f}% — refuel immediately.",
+                fuel, FUEL_CRITICAL))
+        elif fuel <= FUEL_WARNING:
+            alerts.append(FleetAlert(
+                vid, "LOW_FUEL", AlertSeverity.WARNING,
+                f"Fuel at {fuel:.1f}% — plan refuel soon.",
+                fuel, FUEL_WARNING))
+
+        # Speed checks
+        if speed >= SPEED_CRITICAL:
+            alerts.append(FleetAlert(
+                vid, "SPEEDING", AlertSeverity.CRITICAL,
+                f"Vehicle speeding at {speed:.1f} km/h.",
+                speed, SPEED_CRITICAL))
+        elif speed >= SPEED_WARNING:
+            alerts.append(FleetAlert(
+                vid, "SPEEDING", AlertSeverity.WARNING,
+                f"Approaching speed limit at {speed:.1f} km/h.",
+                speed, SPEED_WARNING))
+
+        return alerts
+
+    def calculate_fuel_efficiency_score(self, reading):
+        """
+        Fuel efficiency index 0-100. Higher = more efficient.
+        """
+        speed = reading.get("speed_kmh",    0.0)
+        fuel  = reading.get("fuel_percent", 100.0)
+        if speed == 0:
+            return 100.0
+        estimated_drain = speed * 0.25
+        return round(min(100.0, (fuel / max(estimated_drain, 1.0)) * 10), 2)
+
+    def predict_maintenance_needed(self, reading):
+        """
+        Returns True if the vehicle likely needs maintenance soon.
+        """
+        return (reading.get("engine_temp_c", 80.0) > MAINTENANCE_TEMP and
+                reading.get("fuel_percent",  100.0) < MAINTENANCE_FUEL)
+
+    def classify_alert_severity(self, alerts):
+        """
+        Return the highest severity level from a list of alerts.
+        """
+        if not alerts:
+            return AlertSeverity.INFO
+        if any(a.severity == AlertSeverity.CRITICAL for a in alerts):
+            return AlertSeverity.CRITICAL
+        if any(a.severity == AlertSeverity.WARNING for a in alerts):
+            return AlertSeverity.WARNING
+        return AlertSeverity.INFO

smartfleet_optimizer-0.1.0/fleet_optimization_pkg/models.py

@@ -0,0 +1,89 @@
+"""
+models.py
+Data models for the fleet optimization engine.
+AlertSeverity, FleetAlert and VehicleRiskProfile are used by
+TelemetryAnalyzer and consumed by the Django app and Lambda function.
+"""
+from enum import Enum
+
+
+class AlertSeverity(Enum):
+    """
+    Severity levels for fleet alerts.
+    """
+    INFO     = "INFO"
+    WARNING  = "WARNING"
+    CRITICAL = "CRITICAL"
+
+
+class FleetAlert:
+    """
+    A single threshold breach for one vehicle.
+
+    Attributes:
+        vehicle_id (str): Which vehicle triggered the alert
+        alert_type (str): Category e.g. HIGH_ENGINE_TEMP, LOW_FUEL, SPEEDING
+        severity (AlertSeverity): How urgent this alert is
+        message (str): Human-readable description for the fleet manager
+        value (float): The actual sensor value that triggered the alert
+        threshold (float): The threshold that was breached
+    """
+    def __init__(self, vehicle_id, alert_type, severity,
+                 message, value, threshold):
+        self.vehicle_id  = vehicle_id
+        self.alert_type  = alert_type
+        self.severity    = severity
+        self.message     = message
+        self.value       = value
+        self.threshold   = threshold
+
+    def to_dict(self):
+        """Serialise to dict for JSON encoding or DynamoDB storage."""
+        return {
+            "vehicle_id":  self.vehicle_id,
+            "alert_type":  self.alert_type,
+            "severity":    self.severity.value,
+            "message":     self.message,
+            "value":       self.value,
+            "threshold":   self.threshold,
+        }
+
+    def __repr__(self):
+        return (f"FleetAlert({self.severity.value}: {self.alert_type} "
+                f"for {self.vehicle_id}, value={self.value})")
+
+
+class VehicleRiskProfile:
+    """
+    Composite risk assessment for a single vehicle reading.
+    """
+    def __init__(self, vehicle_id, risk_score, alerts,
+                 fuel_efficiency_score, maintenance_due):
+        self.vehicle_id            = vehicle_id
+        self.risk_score            = round(risk_score, 2)
+        self.risk_label            = self._label(risk_score)
+        self.alerts                = alerts
+        self.fuel_efficiency_score = round(fuel_efficiency_score, 2)
+        self.maintenance_due       = maintenance_due
+
+    @staticmethod
+    def _label(score):
+        """Map numeric score to a human-readable risk band."""
+        if score >= 75: return "CRITICAL"
+        if score >= 50: return "HIGH"
+        if score >= 25: return "MEDIUM"
+        return "LOW"
+
+    def to_dict(self):
+        return {
+            "vehicle_id":            self.vehicle_id,
+            "risk_score":            self.risk_score,
+            "risk_label":            self.risk_label,
+            "alerts":                [a.to_dict() for a in self.alerts],
+            "fuel_efficiency_score": self.fuel_efficiency_score,
+            "maintenance_due":       self.maintenance_due,
+        }
+
+    def __repr__(self):
+        return (f"VehicleRiskProfile({self.vehicle_id}: {self.risk_label} "
+                f"score={self.risk_score}, alerts={len(self.alerts)})")

smartfleet_optimizer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

smartfleet_optimizer-0.1.0/setup.py

@@ -0,0 +1,22 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="smartfleet-optimizer",
+    version="0.1.0",
+    author="Satvik T M",
+    author_email="satvikw007@gmail.com",
+    description="Analytics library for fleet telemetry: risk scoring, alerts, maintenance prediction",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    packages=setuptools.find_packages(),
+    install_requires=[],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+)

smartfleet_optimizer-0.1.0/smartfleet_optimizer.egg-info/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: smartfleet-optimizer
+Version: 0.1.0
+Summary: Analytics library for fleet telemetry: risk scoring, alerts, maintenance prediction
+Author: Satvik T M
+Author-email: satvikw007@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# fleet-optimization-engine-satvik25159712
+
+Analytics library for fleet telemetry data. Provides risk scoring,
+alert detection, fuel efficiency analysis and maintenance prediction.
+
+## Install
+pip install fleet-optimization-engine-satvik25159712
+
+## Quick start
+from fleet_optimization_pkg import TelemetryAnalyzer
+analyzer = TelemetryAnalyzer()
+profile = analyzer.build_risk_profile({
+    "vehicle_id": "VAN-001", "speed_kmh": 50,
+    "fuel_percent": 75, "engine_temp_c": 85
+})
+print(profile.risk_label)

smartfleet_optimizer-0.1.0/smartfleet_optimizer.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+fleet_optimization_pkg/__init__.py
+fleet_optimization_pkg/analyzer.py
+fleet_optimization_pkg/models.py
+smartfleet_optimizer.egg-info/PKG-INFO
+smartfleet_optimizer.egg-info/SOURCES.txt
+smartfleet_optimizer.egg-info/dependency_links.txt
+smartfleet_optimizer.egg-info/top_level.txt
+tests/test_analyzer.py

smartfleet_optimizer-0.1.0/smartfleet_optimizer.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

smartfleet_optimizer-0.1.0/smartfleet_optimizer.egg-info/top_level.txt

@@ -0,0 +1 @@
+fleet_optimization_pkg

smartfleet_optimizer-0.1.0/tests/test_analyzer.py

@@ -0,0 +1,130 @@
+"""
+test_analyzer.py
+Unit tests for fleet_optimization_pkg.
+"""
+import pytest
+from fleet_optimization_pkg.analyzer import TelemetryAnalyzer
+from fleet_optimization_pkg.models import AlertSeverity, VehicleRiskProfile
+
+
+@pytest.fixture
+def analyzer():
+    return TelemetryAnalyzer()
+
+@pytest.fixture
+def normal_reading():
+    return {"vehicle_id": "VAN-001", "speed_kmh": 50.0,
+            "fuel_percent": 75.0, "engine_temp_c": 85.0}
+
+@pytest.fixture
+def critical_reading():
+    return {"vehicle_id": "VAN-002", "speed_kmh": 112.0,
+            "fuel_percent": 5.0, "engine_temp_c": 115.0}
+
+
+class TestRiskScore:
+
+    def test_normal_vehicle_scores_zero(self, analyzer, normal_reading):
+        assert analyzer.calculate_risk_score(normal_reading) == 0.0
+
+    def test_critical_vehicle_scores_high(self, analyzer, critical_reading):
+        assert analyzer.calculate_risk_score(critical_reading) >= 80.0
+
+    def test_score_is_between_0_and_100(self, analyzer, critical_reading):
+        score = analyzer.calculate_risk_score(critical_reading)
+        assert 0.0 <= score <= 100.0
+
+    def test_score_increases_with_engine_temp(self, analyzer):
+        low  = {"vehicle_id": "X", "speed_kmh": 0,
+                "fuel_percent": 80, "engine_temp_c": 85}
+        high = {"vehicle_id": "X", "speed_kmh": 0,
+                "fuel_percent": 80, "engine_temp_c": 115}
+        assert analyzer.calculate_risk_score(high) > \
+               analyzer.calculate_risk_score(low)
+
+
+class TestAlertDetection:
+
+    def test_no_alerts_for_normal_vehicle(self, analyzer, normal_reading):
+        assert analyzer.detect_alerts(normal_reading) == []
+
+    def test_critical_reading_generates_alerts(self, analyzer, critical_reading):
+        assert len(analyzer.detect_alerts(critical_reading)) >= 2
+
+    def test_high_temp_critical_alert(self, analyzer):
+        r = {"vehicle_id": "X", "speed_kmh": 50,
+             "fuel_percent": 60, "engine_temp_c": 115}
+        alerts = analyzer.detect_alerts(r)
+        assert any(a.alert_type == "HIGH_ENGINE_TEMP" and
+                   a.severity == AlertSeverity.CRITICAL for a in alerts)
+
+    def test_low_fuel_warning_alert(self, analyzer):
+        r = {"vehicle_id": "X", "speed_kmh": 50,
+             "fuel_percent": 15.0, "engine_temp_c": 85}
+        alerts = analyzer.detect_alerts(r)
+        assert any(a.alert_type == "LOW_FUEL" for a in alerts)
+
+    def test_critical_fuel_alert(self, analyzer):
+        r = {"vehicle_id": "X", "speed_kmh": 50,
+             "fuel_percent": 5.0, "engine_temp_c": 85}
+        alerts = analyzer.detect_alerts(r)
+        assert any(a.severity == AlertSeverity.CRITICAL for a in alerts)
+
+    def test_speeding_alert(self, analyzer):
+        r = {"vehicle_id": "X", "speed_kmh": 112.0,
+             "fuel_percent": 60, "engine_temp_c": 85}
+        alerts = analyzer.detect_alerts(r)
+        assert any(a.alert_type == "SPEEDING" for a in alerts)
+
+
+class TestFuelEfficiency:
+
+    def test_stationary_scores_100(self, analyzer):
+        r = {"vehicle_id": "X", "speed_kmh": 0,
+             "fuel_percent": 80, "engine_temp_c": 85}
+        assert analyzer.calculate_fuel_efficiency_score(r) == 100.0
+
+    def test_score_in_valid_range(self, analyzer, normal_reading):
+        score = analyzer.calculate_fuel_efficiency_score(normal_reading)
+        assert 0.0 <= score <= 100.0
+
+
+class TestMaintenancePrediction:
+
+    def test_healthy_vehicle_no_maintenance(self, analyzer, normal_reading):
+        assert analyzer.predict_maintenance_needed(normal_reading) is False
+
+    def test_high_temp_low_fuel_needs_maintenance(self, analyzer):
+        r = {"vehicle_id": "X", "speed_kmh": 50,
+             "fuel_percent": 18.0, "engine_temp_c": 98.0}
+        assert analyzer.predict_maintenance_needed(r) is True
+
+
+class TestSeverityClassification:
+
+    def test_empty_alerts_returns_info(self, analyzer):
+        assert analyzer.classify_alert_severity([]) == AlertSeverity.INFO
+
+    def test_critical_alerts_returns_critical(self, analyzer, critical_reading):
+        alerts = analyzer.detect_alerts(critical_reading)
+        assert analyzer.classify_alert_severity(alerts) == AlertSeverity.CRITICAL
+
+
+class TestRiskProfile:
+
+    def test_returns_correct_type(self, analyzer, normal_reading):
+        assert isinstance(analyzer.build_risk_profile(normal_reading),
+                          VehicleRiskProfile)
+
+    def test_normal_vehicle_is_low(self, analyzer, normal_reading):
+        assert analyzer.build_risk_profile(normal_reading).risk_label == "LOW"
+
+    def test_critical_vehicle_label(self, analyzer, critical_reading):
+        label = analyzer.build_risk_profile(critical_reading).risk_label
+        assert label in ("HIGH", "CRITICAL")
+
+    def test_to_dict_has_all_keys(self, analyzer, normal_reading):
+        d = analyzer.build_risk_profile(normal_reading).to_dict()
+        assert set(d.keys()) == {"vehicle_id", "risk_score", "risk_label",
+                                  "alerts", "fuel_efficiency_score",
+                                  "maintenance_due"}