fix(machine_id): change the last processed id to dict to better get the

SETUP.md

@@ -0,0 +1,152 @@
+# Setup and Recreation Guide
+
+This document provides instructions on how to set up and recreate the Predictive Machine project locally without overwriting the `README.md` file (which is essential for Hugging Face Spaces).
+
+## Prerequisites
+
+- Python 3.8 or higher
+- pip (Python package manager)
+- Git
+- Docker (optional, for containerized deployment)
+
+## Local Setup
+
+### 1. Clone the Repository
+
+```bash
+git clone https://huggingface.co/spaces/Asah-ML-Copilot-A25-CS047/Predictive-Machine
+cd Predictive-Machine
+```
+
+### 2. Create a Virtual Environment
+
+```bash
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+### 3. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 4. Download the Dataset
+
+The project uses the Kaggle dataset: [Machine Predictive Maintenance Classification](https://www.kaggle.com/datasets/shivamb/machine-predictive-maintenance-classification/data)
+
+- Download the dataset from Kaggle
+- Extract it to a `data/` directory in the project root
+- Or set up Kaggle API credentials:
+
+```bash
+pip install kaggle
+kaggle datasets download -d shivamb/machine-predictive-maintenance-classification
+unzip machine-predictive-maintenance-classification.zip -d data/
+```
+
+### 5. Run the Application
+
+```bash
+uvicorn app:app --reload
+```
+
+
+## Preserving README.md for Hugging Face Spaces
+
+**Important:** The `README.md` file contains critical Hugging Face Spaces configuration metadata (YAML front matter). When updating the project:
+
+1. **Never overwrite or delete `README.md`**
+2. Keep the YAML header intact:
+   ```yaml
+   ---
+   title: Predictive Machine
+   emoji: 🚨
+   colorFrom: pink
+   colorTo: indigo
+   sdk: docker
+   pinned: true
+   license: apache-2.0
+   short_description: Predictive Machine Copilot for Asah by Dicoding x Accenture
+   datasets: [https://www.kaggle.com/datasets/shivamb/machine-predictive-maintenance-classification/data]
+   ---
+   ```
+3. Use this `SETUP.md` file for development documentation instead
+4. If you need to update README.md content, only modify the area AFTER the closing `---`
+
+## Docker Deployment
+
+### Build the Docker Image
+
+```bash
+docker build -t predictive-machine .
+```
+
+### Run the Container
+
+```bash
+docker run -p 7860:7860 predictive-machine
+```
+
+The application will be available at `http://localhost:7860`
+
+## Project Structure
+
+```
+Predictive-Machine/
+├── README.md              # Hugging Face Spaces config (DO NOT OVERWRITE)
+├── SETUP.md              # This file - local setup instructions
+├── Dockerfile            # Docker configuration
+├── requirements.txt      # Python dependencies
+├── app.py               # Main application
+├── data/                # Dataset directory
+├── models/              # Trained models
+└── src/                 # Source code modules
+```
+
+## Development Workflow
+
+1. Create a new branch for features:
+   ```bash
+   git checkout -b feature/your-feature-name
+   ```
+
+2. Make changes and test locally
+
+3. Commit and push changes:
+   ```bash
+   git add .
+   git commit -m "Description of changes"
+   git push origin feature/your-feature-name
+   ```
+
+4. Create a pull request
+
+5. Once merged, the changes will be reflected in the Hugging Face Spaces deployment
+
+## Troubleshooting
+
+### Dataset Download Issues
+- Ensure you have Kaggle API credentials configured: `~/.kaggle/kaggle.json`
+- Or download manually from Kaggle and place files in `data/` directory
+
+### Dependency Conflicts
+```bash
+pip install --upgrade pip
+pip install -r requirements.txt --force-reinstall
+```
+
+### Docker Build Issues
+```bash
+docker build --no-cache -t predictive-machine .
+```
+
+## License
+
+This project is licensed under the Apache 2.0 License - see LICENSE file for details.
+
+## Resources
+
+- [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+- [Hugging Face Spaces Config Reference](https://huggingface.co/docs/hub/spaces-config-reference)
+- [Dataset: Machine Predictive Maintenance Classification](https://www.kaggle.com/datasets/shivamb/machine-predictive-maintenance-classification)

app.py

@@ -88,7 +88,7 @@ def predict_machine():
         if not binary_result.get("success"):
             logger.error(f"Binary prediction failed for {machine_name}: {binary_result.get('error')}")
             if binary_result.get("error") != "Data already predicted":
-                database.reset_last_processed_id()
+                database.reset_last_processed_id(machine_id)
             all_results.append(binary_result)
             continue
         
@@ -124,7 +124,7 @@ def predict_machine():
                 
                 if save_result is None or save_result.get("error"):
                     logger.error(f"Failed to save prediction for UDI {sensor_udi} - resetting for retry")
-                    database.reset_last_processed_id()
+                    database.reset_last_processed_id(machine_id)
                     all_results.append({
                         "machine_name": machine_name,
                         "success": False,
@@ -132,7 +132,7 @@ def predict_machine():
                     })
                     continue
                 logger.info(f"Prediction successfully saved for UDI {sensor_udi}")
-                database.mark_as_processed(sensor_udi)
+                database.mark_as_processed(machine_id, sensor_udi)
                 
                 all_results.append({
                     "machine_name": machine_name,
@@ -150,7 +150,7 @@ def predict_machine():
             else:
                 logger.error(f"Classification or time series prediction failed for UDI {sensor_udi}")
                 if not (isinstance(classification_result, dict) and classification_result.get("error") == "Data already predicted"):
-                    database.reset_last_processed_id()
+                    database.reset_last_processed_id(machine_id)
                 all_results.append(binary_result)
         else:
             logger.info(f"No failure predicted for UDI {sensor_udi}")
@@ -165,7 +165,7 @@ def predict_machine():
             )
             
             if save_result and save_result.get("success"):
-                database.mark_as_processed(sensor_udi)
+                database.mark_as_processed(machine_id, sensor_udi)
             
             all_results.append({
                 "machine_name": machine_name,

database.py

@@ -17,18 +17,21 @@ class Database():
         
         try:
             self.__supabase: Client = create_client(self.__url, self.__key)
-            self.__last_processed_id = None
+            self.__last_processed_ids = {}
             logger.info("Database connection established successfully")
         except Exception as e:
             logger.critical(f"Failed to create Supabase client: {str(e)}")
             raise
             
-    def mark_as_processed(self, udi):
-        self.__last_processed_id = udi
+    def mark_as_processed(self, machine_id, udi):
+        if machine_id not in self.__last_processed_ids:
+            self.__last_processed_ids[machine_id] = []
+        self.__last_processed_ids[machine_id].append(udi)
         logger.info(f"Marked UDI {udi} as processed")
     
-    def reset_last_processed_id(self):
-        self.__last_processed_id = None
+    def reset_last_processed_id(self, machine_id):
+        if machine_id in self.__last_processed_ids:
+            self.__last_processed_ids[machine_id] = []
         logger.info("Reset last_processed_id - data can be reprocessed")
     
     def get_all_machine_id(self):
@@ -42,7 +45,7 @@ class Database():
         except Exception as e:
             return e
     
-    def get_sensor_readings(self, limit, machine_id):
+     def get_sensor_readings(self, limit, machine_id):
         try:
             query = self.__supabase.table("sensor_readings").select("*")
             
@@ -61,19 +64,18 @@ class Database():
                 return None
             
             if limit == 1:
-                # Single reading mode - check for duplicates
                 current_reading = response.data[0]
+                current_udi = current_reading.get("udi")
                 
-                # Prevent reprocessing the same UDI
-                if self.__last_processed_id == current_reading.get("udi"):
-                    logger.warning(f"Duplicate data detected - UDI {current_reading.get('udi')} already processed")
+                machine_processed_udis = self.__last_processed_ids.get(machine_id, [])
+                if current_udi in machine_processed_udis:
+                    logger.warning(f"Duplicate data detected for Machine {machine_id} - UDI {current_udi} already processed")
                     return {
                         "success": False,
                         "message": "Data already predicted",
                     }
                 
-                self.__last_processed_id = current_reading.get("udi")
-                logger.debug(f"Retrieved single sensor reading - UDI: {current_reading.get('udi')}, Machine: {current_reading.get('machine_id')}")
+                logger.debug(f"Retrieved single sensor reading - UDI: {current_udi}, Machine: {machine_id}")
                 return current_reading
 
             else: