vnai 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

vnai/flow/queue.py

@@ -1,58 +1,134 @@
-_C='category'
-_B=True
-_A=None
-import time,threading,json
+# vnai/flow/queue.py
+# Data buffering system
+
+import time
+import threading
+import json
 from datetime import datetime
 from pathlib import Path
+
 class Buffer:
-	_instance=_A;_lock=threading.Lock()
-	def __new__(A):
-		with A._lock:
-			if A._instance is _A:A._instance=super(Buffer,A).__new__(A);A._instance._initialize()
-			return A._instance
-	def _initialize(A):A.data=[];A.lock=threading.Lock();A.max_size=1000;A.backup_interval=300;A.home_dir=Path.home();A.project_dir=A.home_dir/'.vnstock';A.project_dir.mkdir(exist_ok=_B);A.data_dir=A.project_dir/'data';A.data_dir.mkdir(exist_ok=_B);A.backup_path=A.data_dir/'buffer_backup.json';A._load_from_backup();A._start_backup_thread()
-	def _load_from_backup(A):
-		if A.backup_path.exists():
-			try:
-				with open(A.backup_path,'r')as B:C=json.load(B)
-				with A.lock:A.data=C
-			except:pass
-	def _save_to_backup(A):
-		with A.lock:
-			if not A.data:return
-			try:
-				with open(A.backup_path,'w')as B:json.dump(A.data,B)
-			except:pass
-	def _start_backup_thread(A):
-		def B():
-			while _B:time.sleep(A.backup_interval);A._save_to_backup()
-		C=threading.Thread(target=B,daemon=_B);C.start()
-	def add(A,item,category=_A):
-		D='timestamp';C=category;B=item
-		with A.lock:
-			if isinstance(B,dict):
-				if D not in B:B[D]=datetime.now().isoformat()
-				if C:B[_C]=C
-			A.data.append(B)
-			if len(A.data)>A.max_size:A.data=A.data[-A.max_size:]
-			if len(A.data)%100==0:A._save_to_backup()
-			return len(A.data)
-	def get(A,count=_A,category=_A):
-		D=category;C=count
-		with A.lock:
-			if D:B=[A for A in A.data if A.get(_C)==D]
-			else:B=A.data.copy()
-			if C:return B[:C]
-			else:return B
-	def clear(A,category=_A):
-		B=category
-		with A.lock:
-			if B:A.data=[A for A in A.data if A.get(_C)!=B]
-			else:A.data=[]
-			A._save_to_backup();return len(A.data)
-	def size(A,category=_A):
-		B=category
-		with A.lock:
-			if B:return len([A for A in A.data if A.get(_C)==B])
-			else:return len(A.data)
-buffer=Buffer()
+    """Manages data buffering with persistence"""
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(Buffer, cls).__new__(cls)
+                cls._instance._initialize()
+            return cls._instance
+    
+    def _initialize(self):
+        """Initialize buffer"""
+        self.data = []
+        self.lock = threading.Lock()
+        self.max_size = 1000
+        self.backup_interval = 300  # 5 minutes
+        
+        # Setup data directory
+        self.home_dir = Path.home()
+        self.project_dir = self.home_dir / ".vnstock"
+        self.project_dir.mkdir(exist_ok=True)
+        self.data_dir = self.project_dir / 'data'
+        self.data_dir.mkdir(exist_ok=True)
+        self.backup_path = self.data_dir / "buffer_backup.json"
+        
+        # Load from backup if exists
+        self._load_from_backup()
+        
+        # Start backup thread
+        self._start_backup_thread()
+    
+    def _load_from_backup(self):
+        """Load data from backup file"""
+        if self.backup_path.exists():
+            try:
+                with open(self.backup_path, 'r') as f:
+                    backup_data = json.load(f)
+                    
+                with self.lock:
+                    self.data = backup_data
+            except:
+                pass
+    
+    def _save_to_backup(self):
+        """Save data to backup file"""
+        with self.lock:
+            if not self.data:
+                return
+                
+            try:
+                with open(self.backup_path, 'w') as f:
+                    json.dump(self.data, f)
+            except:
+                pass
+    
+    def _start_backup_thread(self):
+        """Start background backup thread"""
+        def backup_task():
+            while True:
+                time.sleep(self.backup_interval)
+                self._save_to_backup()
+        
+        backup_thread = threading.Thread(target=backup_task, daemon=True)
+        backup_thread.start()
+    
+    def add(self, item, category=None):
+        """Add item to buffer"""
+        with self.lock:
+            # Add metadata
+            if isinstance(item, dict):
+                if "timestamp" not in item:
+                    item["timestamp"] = datetime.now().isoformat()
+                if category:
+                    item["category"] = category
+            
+            # Add to buffer
+            self.data.append(item)
+            
+            # Trim if exceeds max size
+            if len(self.data) > self.max_size:
+                self.data = self.data[-self.max_size:]
+            
+            # Save to backup if buffer gets large
+            if len(self.data) % 100 == 0:
+                self._save_to_backup()
+                
+            return len(self.data)
+    
+    def get(self, count=None, category=None):
+        """Get items from buffer with optional filtering"""
+        with self.lock:
+            if category:
+                filtered_data = [item for item in self.data if item.get("category") == category]
+            else:
+                filtered_data = self.data.copy()
+            
+            if count:
+                return filtered_data[:count]
+            else:
+                return filtered_data
+    
+    def clear(self, category=None):
+        """Clear buffer, optionally by category"""
+        with self.lock:
+            if category:
+                self.data = [item for item in self.data if item.get("category") != category]
+            else:
+                self.data = []
+            
+            self._save_to_backup()
+            return len(self.data)
+    
+    def size(self, category=None):
+        """Get buffer size, optionally by category"""
+        with self.lock:
+            if category:
+                return len([item for item in self.data if item.get("category") == category])
+            else:
+                return len(self.data)
+
+# Create singleton instance
+buffer = Buffer()