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

vnai/flow/queue.py

@@ -1,134 +1,58 @@
-# vnai/flow/queue.py
-# Data buffering system
-
-import time
-import threading
-import json
+_C='category'
+_B=True
+_A=None
+import time,threading,json
 from datetime import datetime
 from pathlib import Path
-
 class 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()
+	_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()