Update app.py

app.py

@@ -97,42 +97,43 @@ cv2.ocl.setUseOpenCL(True)
 class UsageLogger:
     """Simple logger to record app usage timestamps"""
     def __init__(self, log_filename="usage_logs.json"):
-        # Get the current working directory for the application
-        try:
-            # Create logs directory if it doesn't exist
-            self.logs_dir = os.path.join(os.getcwd(), "logs")
-            os.makedirs(self.logs_dir, exist_ok=True)
-            self.log_file = os.path.join(self.logs_dir, log_filename)
-        except Exception as e:
-            # Fallback to a directory we should have write access to
-            print(f"Error creating logs directory: {str(e)}")
-            temp_dir = tempfile.gettempdir()
-            self.logs_dir = os.path.join(temp_dir, "image_processor_logs")
-            os.makedirs(self.logs_dir, exist_ok=True)
-            self.log_file = os.path.join(self.logs_dir, log_filename)
+        # Use the persistent storage directory in Hugging Face Spaces
+        import os
+        
+        # Hugging Face Spaces persistent storage path
+        self.logs_dir = os.path.join("/home/user/app", "logs")
+        os.makedirs(self.logs_dir, exist_ok=True)
+        self.log_file = os.path.join(self.logs_dir, log_filename)
         
         print(f"Log file location: {self.log_file}")
         self.ensure_log_file_exists()
     
     def ensure_log_file_exists(self):
         """Create log file with empty array if it doesn't exist"""
+        import os
+        import json
+        
         try:
             if not os.path.exists(self.log_file):
                 with open(self.log_file, 'w') as f:
-                    json.dump({"visits": []}, f)
+                    json.dump({"visits": [], "features": []}, f)
             # Test if file is readable/writable
             with open(self.log_file, 'r+') as f:
                 pass
         except Exception as e:
             print(f"Error accessing log file: {str(e)}")
-            # Create a new log file in a different location as fallback
-            self.log_file = os.path.join(tempfile.gettempdir(), "image_processor_logs.json")
+            # Try to create a logs.json file directly in the app root
+            self.log_file = "/home/user/app/logs.json"
             print(f"Using fallback log file: {self.log_file}")
             with open(self.log_file, 'w') as f:
-                json.dump({"visits": []}, f)
+                json.dump({"visits": [], "features": []}, f)
     
     def log_visit(self):
         """Log a timestamp when the app is visited/used"""
+        import datetime
+        import json
+        import os
+        
         current_time = datetime.datetime.now().isoformat()
         
         try:
@@ -145,10 +146,10 @@ class UsageLogger:
                     with open(self.log_file, 'r') as f:
                         logs = json.load(f)
                 else:
-                    logs = {"visits": []}
+                    logs = {"visits": [], "features": []}
             except (json.JSONDecodeError, FileNotFoundError):
                 # If file is corrupt or doesn't exist, start fresh
-                logs = {"visits": []}
+                logs = {"visits": [], "features": []}
             
             # Append new timestamp
             logs["visits"].append({"timestamp": current_time})
@@ -163,10 +164,35 @@ class UsageLogger:
             print(f"Error logging visit: {str(e)}")
             return False
     
-    def log_usage(self, feature_type):
-        """Log when a specific feature is used"""
+    def log_usage(self, feature_type, media_type=None):
+        """Log when a specific feature is used
+        Args:
+            feature_type: The feature used (e.g., 'black_white_image', 'sketch_video')
+            media_type: The type of media processed (e.g., 'image', 'video')
+        """
+        import datetime
+        import json
+        import os
+        
         current_time = datetime.datetime.now().isoformat()
         
+        # Extract media type from feature name if not provided
+        if media_type is None:
+            if "image" in feature_type:
+                media_type = "image"
+            elif "video" in feature_type:
+                media_type = "video"
+            else:
+                media_type = "unknown"
+        
+        # Extract service type
+        if "black_white" in feature_type:
+            service_type = "black_and_white"
+        elif "sketch" in feature_type:
+            service_type = "pencil_sketch"
+        else:
+            service_type = "unknown"
+        
         try:
             # Make sure log directory exists
             os.makedirs(os.path.dirname(self.log_file), exist_ok=True)
@@ -177,22 +203,28 @@ class UsageLogger:
                     with open(self.log_file, 'r') as f:
                         logs = json.load(f)
                 else:
-                    logs = {"visits": []}
+                    logs = {"visits": [], "features": []}
             except (json.JSONDecodeError, FileNotFoundError):
                 # If file is corrupt or doesn't exist, start fresh
-                logs = {"visits": []}
+                logs = {"visits": [], "features": []}
+            
+            # Make sure features key exists
+            if "features" not in logs:
+                logs["features"] = []
             
             # Append new usage record
-            logs["visits"].append({
+            logs["features"].append({
                 "timestamp": current_time,
-                "feature": feature_type
+                "feature": feature_type,
+                "service": service_type,
+                "media_type": media_type
             })
             
             # Write updated logs
             with open(self.log_file, 'w') as f:
                 json.dump(logs, f, indent=2)
                 
-            print(f"Feature usage logged: {feature_type} at {current_time}")
+            print(f"Feature usage logged: {feature_type} ({media_type}) at {current_time}")
             return True
         except Exception as e:
             print(f"Error logging usage: {str(e)}")