smartfleet-simulator 0.1.0__tar.gz

smartfleet_simulator-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_simulator-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: smartfleet-simulator
+Version: 0.1.0
+Summary: Reusable library for simulating vehicle fleet telemetry
+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-simulator-satvik25159712
+
+Reusable Python library for simulating delivery vehicle fleet telemetry.
+Generates GPS, speed, fuel and engine temperature readings and posts
+them to AWS API Gateway.
+
+## Install
+pip install fleet-simulator-satvik25159712
+
+## Quick start
+from fleet_simulator_pkg import FleetSimulator
+sim = FleetSimulator()
+sim.run(dry_run=True, max_ticks=5)

smartfleet_simulator-0.1.0/README.md

@@ -0,0 +1,13 @@
+# fleet-simulator-satvik25159712
+
+Reusable Python library for simulating delivery vehicle fleet telemetry.
+Generates GPS, speed, fuel and engine temperature readings and posts
+them to AWS API Gateway.
+
+## Install
+pip install fleet-simulator-satvik25159712
+
+## Quick start
+from fleet_simulator_pkg import FleetSimulator
+sim = FleetSimulator()
+sim.run(dry_run=True, max_ticks=5)

smartfleet_simulator-0.1.0/fleet_simulator_pkg/__init__.py

@@ -0,0 +1,6 @@
+from .vehicle import Vehicle
+from .simulator import FleetSimulator
+from .telemetry import TelemetryReading
+
+__version__ = "0.1.0"
+__all__ = ["Vehicle", "FleetSimulator", "TelemetryReading"]

smartfleet_simulator-0.1.0/fleet_simulator_pkg/simulator.py

@@ -0,0 +1,113 @@
+"""
+simulator.py
+Manages a fleet of Vehicle objects and drives the telemetry loop.
+Sends TelemetryReading objects to AWS API Gateway via HTTP POST.
+"""
+import json
+import time
+import urllib.request
+import urllib.error
+from .vehicle import Vehicle
+from .telemetry import TelemetryReading
+
+DEFAULT_FLEET = [
+    {"vehicle_id": "VAN-001", "driver_name": "Raghu Bandi",  "route_id": "ROUTE-D1"},
+    {"vehicle_id": "VAN-002", "driver_name": "Manju Kolar",  "route_id": "ROUTE-D2"},
+    {"vehicle_id": "VAN-003", "driver_name": "Shubham Dube", "route_id": "ROUTE-D3"},
+    {"vehicle_id": "VAN-004", "driver_name": "Pranith Raj", "route_id": "ROUTE-D4"},
+    {"vehicle_id": "VAN-005", "driver_name": "Nikhil Bandi", "route_id": "ROUTE-D5"},
+]
+
+
+class FleetSimulator:
+    """
+    Manages a fleet of vehicles and drives a continuous telemetry loop.
+    """
+
+    def __init__(self, fleet_config=None, api_url=None, api_key=None):
+        """
+        Initialise with a fleet and optional API target.
+
+        Args:
+            fleet_config (list): List of dicts with vehicle_id,
+                driver_name, route_id. Uses DEFAULT_FLEET if None.
+            api_url (str): API Gateway endpoint URL.
+            api_key (str): Optional x-api-key header value.
+        """
+        config = fleet_config if fleet_config is not None else DEFAULT_FLEET
+        self.vehicles = [
+            Vehicle(v["vehicle_id"], v["driver_name"], v["route_id"])
+            for v in config
+        ]
+        self.api_url = api_url
+        self.api_key = api_key
+
+    def generate_readings(self):
+        """Advance all vehicles one tick. Returns list of TelemetryReadings."""
+        readings = []
+        for vehicle in self.vehicles:
+            vehicle.update_state()
+            readings.append(TelemetryReading.from_vehicle(vehicle))
+        return readings
+
+    def send_reading(self, reading):
+        """
+        POST a single TelemetryReading to API Gateway.
+        Returns True on HTTP 200/201/202, False on failure.
+        """
+        if not self.api_url:
+            return False
+        payload = json.dumps(reading.to_dict()).encode("utf-8")
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["x-api-key"] = self.api_key
+        req = urllib.request.Request(
+            self.api_url, data=payload, headers=headers, method="POST"
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                return resp.status in (200, 201, 202)
+        except urllib.error.URLError as e:
+            print(f"  [ERROR] {reading.vehicle_id}: {e}")
+            return False
+
+    def run(self, interval_seconds=5.0, max_ticks=None,
+            dry_run=False, on_reading=None):
+        """
+        Start the simulation loop.
+
+        Args:
+            interval_seconds (float): Pause between ticks.
+            max_ticks (int): Stop after this many ticks. None = run forever.
+            dry_run (bool): Print to console instead of sending to AWS.
+            on_reading (callable): Optional callback per reading.
+        """
+        tick = 0
+        print(f"[FleetSimulator] Starting — {len(self.vehicles)} vehicles, "
+              f"interval={interval_seconds}s, dry_run={dry_run}")
+        try:
+            while True:
+                tick += 1
+                readings = self.generate_readings()
+                for reading in readings:
+                    if dry_run or not self.api_url:
+                        print(f"  [tick {tick:04d}] {reading.vehicle_id} | "
+                              f"speed={reading.speed_kmh:.1f}km/h | "
+                              f"fuel={reading.fuel_percent:.1f}% | "
+                              f"temp={reading.engine_temp_c:.1f}C")
+                    else:
+                        ok = self.send_reading(reading)
+                        print(f"  [tick {tick:04d}] {reading.vehicle_id} → "
+                              f"{'OK' if ok else 'FAIL'}")
+                    if on_reading:
+                        on_reading(reading)
+                if max_ticks and tick >= max_ticks:
+                    print(f"[FleetSimulator] Done — {max_ticks} ticks.")
+                    break
+                time.sleep(interval_seconds)
+        except KeyboardInterrupt:
+            print("\n[FleetSimulator] Stopped.")
+
+    def get_fleet_summary(self):
+        """Return current state of all vehicles as a list of dicts."""
+        return [v.to_dict() for v in self.vehicles]

smartfleet_simulator-0.1.0/fleet_simulator_pkg/telemetry.py

@@ -0,0 +1,53 @@
+"""
+telemetry.py
+A timestamped snapshot of one vehicle at one point in time.
+This is the payload sent to AWS API Gateway.
+"""
+import datetime
+
+
+class TelemetryReading:
+    """
+    Immutable snapshot of a vehicle's state at a single moment.
+    """
+
+    def __init__(self, vehicle_id, driver_name, route_id,
+                 lat, lon, speed_kmh, fuel_percent, engine_temp_c):
+        self.vehicle_id   = vehicle_id
+        self.driver_name  = driver_name
+        self.route_id     = route_id
+        self.timestamp    = datetime.datetime.now(
+                                datetime.timezone.utc).isoformat()
+        self.lat          = lat
+        self.lon          = lon
+        self.speed_kmh    = speed_kmh
+        self.fuel_percent = fuel_percent
+        self.engine_temp_c = engine_temp_c
+
+    @classmethod
+    def from_vehicle(cls, vehicle):
+        """Create a reading directly from a Vehicle instance."""
+        return cls(
+            vehicle_id    = vehicle.vehicle_id,
+            driver_name   = vehicle.driver_name,
+            route_id      = vehicle.route_id,
+            lat           = vehicle.lat,
+            lon           = vehicle.lon,
+            speed_kmh     = vehicle.speed_kmh,
+            fuel_percent  = vehicle.fuel_percent,
+            engine_temp_c = vehicle.engine_temp_c,
+        )
+
+    def to_dict(self):
+        """Serialise to a flat dict for JSON encoding."""
+        return {
+            "vehicle_id":    self.vehicle_id,
+            "driver_name":   self.driver_name,
+            "route_id":      self.route_id,
+            "timestamp":     self.timestamp,
+            "lat":           self.lat,
+            "lon":           self.lon,
+            "speed_kmh":     self.speed_kmh,
+            "fuel_percent":  self.fuel_percent,
+            "engine_temp_c": self.engine_temp_c,
+        }

smartfleet_simulator-0.1.0/fleet_simulator_pkg/vehicle.py

@@ -0,0 +1,68 @@
+"""
+vehicle.py
+This file represents a single delivery vehicle with persistent state.
+Each vehicle maintains its own position, speed, fuel and engine
+temperature across telemetry ticks.
+"""
+import random
+
+DEFAULT_LAT = 53.3498
+DEFAULT_LON = -6.2603
+
+
+class Vehicle:
+    """
+    A single fleet vehicle with state that updates each tick.
+    """
+
+    def __init__(self, vehicle_id, driver_name, route_id,
+                 start_lat=DEFAULT_LAT, start_lon=DEFAULT_LON):
+        self.vehicle_id = vehicle_id
+        self.driver_name = driver_name
+        self.route_id = route_id
+        self.lat = start_lat
+        self.lon = start_lon
+        self.speed_kmh = 0.0
+        self.fuel_percent = random.uniform(60.0, 100.0)
+        self.engine_temp_c = random.uniform(75.0, 95.0)
+        # Small random fault probability so some vehicles generate alerts
+        self._fault_probability = random.uniform(0.0, 0.15)
+
+    def update_state(self):
+        """
+        Advance vehicle state by one telemetry tick.
+        Simulates realistic GPS drift, speed changes,
+        fuel drain and occasional engine temperature spikes.
+        """
+        # Simulates a GPS movement 
+        self.lat += random.uniform(-0.005, 0.005)
+        self.lon += random.uniform(-0.005, 0.005)
+
+        # speed transitions
+        speed_delta = random.uniform(-15, 15)
+        self.speed_kmh = max(0.0, min(110.0, self.speed_kmh + speed_delta))
+
+        # Fuel drains proportionally to speed
+        fuel_drain = (self.speed_kmh / 100.0) * random.uniform(0.05, 0.2)
+        self.fuel_percent = max(5.0, self.fuel_percent - fuel_drain)
+
+        # Engine temp — occasionally made to spike on faulty vehicles
+        if random.random() < self._fault_probability:
+            self.engine_temp_c = random.uniform(105.0, 120.0)
+        else:
+            temp_delta = random.uniform(-2, 2)
+            self.engine_temp_c = max(75.0, min(95.0,
+                                    self.engine_temp_c + temp_delta))
+
+    def to_dict(self):
+        """Serialise current state to a dict for JSON encoding."""
+        return {
+            "vehicle_id":    self.vehicle_id,
+            "driver_name":   self.driver_name,
+            "route_id":      self.route_id,
+            "lat":           round(self.lat, 6),
+            "lon":           round(self.lon, 6),
+            "speed_kmh":     round(self.speed_kmh, 2),
+            "fuel_percent":  round(self.fuel_percent, 2),
+            "engine_temp_c": round(self.engine_temp_c, 2),
+        }

smartfleet_simulator-0.1.0/setup.cfg

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

smartfleet_simulator-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-simulator",
+    version="0.1.0",
+    author="Satvik T M",
+    author_email="satvikw007@gmail.com",
+    description="Reusable library for simulating vehicle fleet telemetry",
+    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_simulator-0.1.0/smartfleet_simulator.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: smartfleet-simulator
+Version: 0.1.0
+Summary: Reusable library for simulating vehicle fleet telemetry
+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-simulator-satvik25159712
+
+Reusable Python library for simulating delivery vehicle fleet telemetry.
+Generates GPS, speed, fuel and engine temperature readings and posts
+them to AWS API Gateway.
+
+## Install
+pip install fleet-simulator-satvik25159712
+
+## Quick start
+from fleet_simulator_pkg import FleetSimulator
+sim = FleetSimulator()
+sim.run(dry_run=True, max_ticks=5)

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

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+fleet_simulator_pkg/__init__.py
+fleet_simulator_pkg/simulator.py
+fleet_simulator_pkg/telemetry.py
+fleet_simulator_pkg/vehicle.py
+smartfleet_simulator.egg-info/PKG-INFO
+smartfleet_simulator.egg-info/SOURCES.txt
+smartfleet_simulator.egg-info/dependency_links.txt
+smartfleet_simulator.egg-info/top_level.txt
+tests/test_simulator.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+fleet_simulator_pkg

smartfleet_simulator-0.1.0/tests/test_simulator.py

@@ -0,0 +1,85 @@
+"""
+test_simulator.py
+Unit tests for fleet_simulator_pkg.
+Run with: python3 -m pytest tests/ -v
+"""
+from fleet_simulator_pkg.vehicle import Vehicle
+from fleet_simulator_pkg.telemetry import TelemetryReading
+from fleet_simulator_pkg.simulator import FleetSimulator
+
+
+class TestVehicle:
+
+    def test_initialises_with_correct_id(self):
+        v = Vehicle("VAN-001", "Raghu Bandi", "ROUTE-D1")
+        assert v.vehicle_id == "VAN-001"
+
+    def test_fuel_starts_within_range(self):
+        v = Vehicle("VAN-001", "Raghu Bandi", "ROUTE-D1")
+        assert 60.0 <= v.fuel_percent <= 100.0
+
+    def test_fuel_drains_after_updates(self):
+        v = Vehicle("VAN-001", "Raghu Bandi", "ROUTE-D1")
+        initial = v.fuel_percent
+        for _ in range(20):
+            v.update_state()
+        assert v.fuel_percent <= initial
+
+    def test_speed_stays_within_bounds(self):
+        v = Vehicle("VAN-001", "Raghu Bandi", "ROUTE-D1")
+        for _ in range(50):
+            v.update_state()
+        assert 0.0 <= v.speed_kmh <= 110.0
+
+    def test_to_dict_has_all_keys(self):
+        v = Vehicle("VAN-001", "Raghu Bandi", "ROUTE-D1")
+        keys = set(v.to_dict().keys())
+        assert keys == {"vehicle_id", "driver_name", "route_id",
+                        "lat", "lon", "speed_kmh",
+                        "fuel_percent", "engine_temp_c"}
+
+
+class TestTelemetryReading:
+
+    def test_from_vehicle_captures_id(self):
+        v = Vehicle("VAN-002", "Manju Kolar", "ROUTE-D2")
+        r = TelemetryReading.from_vehicle(v)
+        assert r.vehicle_id == "VAN-002"
+
+    def test_timestamp_is_utc_iso(self):
+        v = Vehicle("VAN-002", "Manju Kolar", "ROUTE-D2")
+        r = TelemetryReading.from_vehicle(v)
+        assert "T" in r.timestamp
+        assert "+" in r.timestamp or "Z" in r.timestamp
+
+    def test_to_dict_includes_timestamp(self):
+        v = Vehicle("VAN-003", "Shubham Dube", "ROUTE-D3")
+        d = TelemetryReading.from_vehicle(v).to_dict()
+        assert "timestamp" in d
+
+
+class TestFleetSimulator:
+
+    def test_default_fleet_has_five_vehicles(self):
+        sim = FleetSimulator()
+        assert len(sim.vehicles) == 5
+
+    def test_custom_fleet_config(self):
+        sim = FleetSimulator(fleet_config=[
+            {"vehicle_id": "T-01", "driver_name": "Arun", "route_id": "R1"},
+        ])
+        assert len(sim.vehicles) == 1
+        assert sim.vehicles[0].vehicle_id == "T-01"
+
+    def test_generate_readings_count(self):
+        sim = FleetSimulator()
+        assert len(sim.generate_readings()) == 5
+
+    def test_callback_fires_for_each_reading(self):
+        sim = FleetSimulator()
+        collected = []
+        sim.run(interval_seconds=0, max_ticks=2,
+                dry_run=True, on_reading=lambda r: collected.append(r))
+        assert len(collected) == 10  
+        # 5 vehicles x 2 ticks
+