nedo-vision-worker-core 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

nedo_vision_worker_core/__init__.py

@@ -7,7 +7,7 @@ A library for running AI vision processing and detection in the Nedo Vision plat
 from .core_service import CoreService
 from .callbacks import DetectionType, CallbackTrigger, DetectionData, IntervalMetadata
 
-__version__ = "0.3.4"
+__version__ = "0.3.5"
 __all__ = [
     "CoreService", 
     "DetectionType", 

nedo_vision_worker_core/pipeline/PipelineManager.py

@@ -39,6 +39,11 @@ class PipelineManager:
 
         logging.info(f"🚀 Starting Pipeline processing for pipeline: {pipeline_id} | Source: {worker_source_id} ({pipeline.name})")
 
+        # Acquire the video stream (starts it if not already running)
+        if not self.video_manager.acquire_stream(worker_source_id, pipeline_id):
+            logging.error(f"❌ Failed to acquire stream {worker_source_id} for pipeline {pipeline_id}")
+            return
+
         processor = PipelineProcessor(pipeline, detector, False)
         processor.frame_drawer.location_name = pipeline.location_name
         self.processors[pipeline_id] = processor  # Store processor instance
@@ -79,6 +84,10 @@ class PipelineManager:
             self._stopping_pipelines.add(pipeline_id)
 
         try:
+            # Get worker_source_id before removing metadata
+            pipeline = self.pipeline_metadata.get(pipeline_id)
+            worker_source_id = pipeline.worker_source_id if pipeline else None
+
             # Stop AI processing
             processor = self.processors.pop(pipeline_id, None)
             if processor:
@@ -92,6 +101,10 @@ class PipelineManager:
             # Remove metadata
             self.pipeline_metadata.pop(pipeline_id, None)
 
+            # Release the video stream (stops it if no more pipelines use it)
+            if worker_source_id:
+                self.video_manager.release_stream(worker_source_id, pipeline_id)
+
             logging.info(f"✅ Pipeline {pipeline_id} stopped successfully.")
 
         except Exception as e:

nedo_vision_worker_core/pipeline/PipelineProcessor.py

@@ -459,9 +459,10 @@ class PipelineProcessor:
                 logging.error(f"   Cannot get stream URL for {worker_source_id}")
                 return False
             
-            video_manager.remove_stream(worker_source_id)
+            # Use internal methods to restart the stream without affecting reference counting
+            video_manager._stop_stream(worker_source_id)
             time.sleep(1.0)
-            video_manager.add_stream(worker_source_id, stream_url)
+            video_manager._start_stream(worker_source_id, stream_url)
             time.sleep(2.0)
             
             if not video_manager.has_stream(worker_source_id):

nedo_vision_worker_core/pipeline/PipelineSyncThread.py

@@ -103,8 +103,22 @@ class PipelineSyncThread(threading.Thread):
 
         for pid in pipeline_ids:
             db_pipeline = db_pipelines[pid]
+            
+            # Check if pipeline should be stopped (status changed to stop/restart in DB)
+            if db_pipeline.pipeline_status_code in ['stop', 'restart']:
+                if self.pipeline_manager.is_running(pid):
+                    logging.info(f"⏹️ Stopping pipeline due to status change: {pid}")
+                    self.pipeline_manager.stop_pipeline(pid)
+                continue
+            
             processor = self.pipeline_manager.processors.get(pid)
             if not processor:
+                # Pipeline exists in both sets but processor doesn't exist - shouldn't happen
+                # but if it does, try to start it if status is 'run'
+                if db_pipeline.pipeline_status_code == 'run':
+                    logging.warning(f"⚠️ Pipeline {pid} exists locally but has no processor. Restarting...")
+                    detector = self.model_manager.get_detector(db_pipeline.ai_model_id)
+                    self.pipeline_manager.start_pipeline(db_pipeline, detector)
                 continue
 
             local_detector = processor.detector
@@ -114,29 +128,12 @@ class PipelineSyncThread(threading.Thread):
                 processor.enable_debug()
 
     def update_pipeline(self, pid: str, db_pipeline: object, local_detector: object) -> None:
-        """Updates a single pipeline if necessary."""
+        """Updates a single pipeline if necessary (only called for running pipelines)."""
         processor = self.pipeline_manager.processors.get(pid)
         if not processor:
             return
 
-        # Stop/start based on status change
-        if db_pipeline.pipeline_status_code != processor._pipeline.pipeline_status_code:
-            if db_pipeline.pipeline_status_code == 'run':
-                logging.info(f"▶️ Resuming pipeline: {pid}")
-                self.pipeline_manager.start_pipeline(db_pipeline, self.model_manager.get_detector(db_pipeline.ai_model_id))
-            elif db_pipeline.pipeline_status_code in ['stop', 'restart']:
-                logging.info(f"⏹️ Stopping pipeline: {pid}")
-                self.pipeline_manager.stop_pipeline(pid)
-                if db_pipeline.pipeline_status_code == 'restart':
-                    # This will be picked up by the 'add_new_pipelines' logic in the next cycle
-                    return 
-            else:
-                 processor.update_config(db_pipeline) # Update config for non-running pipelines
-            return
-        elif db_pipeline.pipeline_status_code != 'run':
-            processor.update_config(db_pipeline)
-            return
-
+        # At this point, we know db_pipeline.pipeline_status_code == 'run' (checked in caller)
         # Check for significant changes that require a restart
         db_detector = self.model_manager.get_detector(db_pipeline.ai_model_id)
 
@@ -146,7 +143,7 @@ class PipelineSyncThread(threading.Thread):
             local_detector != db_detector
         ])
 
-        if requires_restart and db_pipeline.pipeline_status_code == 'run':
+        if requires_restart:
             logging.info(f"🔄 Restarting pipeline due to significant changes: {pid}")
             self.pipeline_manager.stop_pipeline(pid)
             self.pipeline_manager.start_pipeline(db_pipeline, db_detector)

nedo_vision_worker_core/streams/StreamSyncThread.py

@@ -29,40 +29,67 @@ class StreamSyncThread(threading.Thread):
             try:
                 sources = self.worker_source_repo.get_worker_sources()
                 db_sources = {
-                    source.id: (
+                    source.id: 
                         source.url if source.type_code == "live" 
                         else source.url if source.type_code == "direct"
-                        else self._get_source_file_path(source.file_path), 
-                        source.status_code
-                    ) for source in sources
+                        else self._get_source_file_path(source.file_path)
+                     for source in sources
                 }  # Store latest sources
+                
+                # Get both active streams and pending streams
                 active_stream_ids = set(self.manager.get_active_stream_ids())
+                with self.manager._lock:
+                    pending_stream_ids = set(self.manager.pending_streams.keys())
+                registered_stream_ids = active_stream_ids | pending_stream_ids
 
-                # **1️⃣ Add new streams**
-                for source_id, (url, status_code) in db_sources.items():
-                    if source_id not in active_stream_ids and status_code == "connected":
-                        logging.info(f"🟢 Adding new stream: {source_id} ({url})")
-                        self.manager.add_stream(source_id, url)
+                # **1️⃣ Register new streams (lazy loading - don't start them yet)**
+                for source_id, url in db_sources.items():
+                    if source_id not in registered_stream_ids:
+                        logging.info(f"🟢 Registering new stream: {source_id} ({url})")
+                        self.manager.register_stream(source_id, url)
 
-                # **2️⃣ Remove deleted streams**
-                for stream_id in active_stream_ids:
-                    if stream_id not in db_sources or db_sources[stream_id][1] != "connected":
-                        logging.info(f"🔴 Removing deleted stream: {stream_id}")
-                        self.manager.remove_stream(stream_id)
+                # **2️⃣ Unregister deleted or disconnected streams**
+                for stream_id in registered_stream_ids:
+                    if stream_id not in db_sources:
+                        logging.info(f"🔴 Unregistering stream: {stream_id}")
+                        self.manager.unregister_stream(stream_id)
 
-                active_stream_ids = set(self.manager.get_active_stream_ids())
+                # Refresh registered streams
+                with self.manager._lock:
+                    pending_stream_ids = set(self.manager.pending_streams.keys())
+                registered_stream_ids = active_stream_ids | pending_stream_ids
 
                 # **3️⃣ Update streams if URL has changed**
-                for source_id, (url, status_code) in db_sources.items():
-                    if source_id in active_stream_ids:
-                        existing_url = self.manager.get_stream_url(source_id)
+                for source_id, url in db_sources.items():
+                    if source_id in registered_stream_ids:
+                        # Check if it's an active stream or pending stream
+                        with self.manager._lock:
+                            is_pending = source_id in self.manager.pending_streams
+                            if is_pending:
+                                existing_url = self.manager.pending_streams.get(source_id)
+                            else:
+                                existing_url = None
+                        
+                        if existing_url is None:
+                            # It's an active stream, get URL from stream manager
+                            existing_url = self.manager.get_stream_url(source_id)
+                        
+                        # Only update if URL actually changed
                         if existing_url != url:
-                            logging.info(f"🟡 Updating stream {source_id}: New URL {url}")
-                            self.manager.remove_stream(source_id)
-                            # Add a small delay for device cleanup
-                            if self._is_direct_device(url) or self._is_direct_device(existing_url):
-                                time.sleep(0.5)  # Allow device to be properly released
-                            self.manager.add_stream(source_id, url)
+                            if is_pending:
+                                # It's pending, just update the URL
+                                with self.manager._lock:
+                                    self.manager.pending_streams[source_id] = url
+                                    logging.info(f"🟡 Updated pending stream {source_id} URL")
+                            else:
+                                # It's active, need to restart it
+                                logging.info(f"🟡 Updating active stream {source_id}: New URL {url}")
+                                # Unregister and re-register with new URL
+                                self.manager.unregister_stream(source_id)
+                                # Add a small delay for device cleanup
+                                if self._is_direct_device(url) or self._is_direct_device(existing_url):
+                                    time.sleep(0.5)  # Allow device to be properly released
+                                self.manager.register_stream(source_id, url)
 
             except Exception as e:
                 logging.error(f"⚠️ Error syncing streams from database: {e}")

nedo_vision_worker_core/streams/VideoStreamManager.py

@@ -1,7 +1,6 @@
 import logging
 import time
 import threading
-import cv2
 from typing import Any, Dict, Optional
 
 from .VideoStream import VideoStream
@@ -18,6 +17,11 @@ class VideoStreamManager:
         self.direct_device_streams: Dict[Any, Dict[str, Any]] = {}
         # Per-direct-device locks: {worker_source_id: threading.Lock}
         self.direct_device_locks: Dict[Any, threading.Lock] = {}
+        
+        # Reference counting for lazy loading: {worker_source_id: set of pipeline_ids}
+        self.stream_references: Dict[Any, set] = {}
+        # Store URLs for streams that aren't started yet: {worker_source_id: url}
+        self.pending_streams: Dict[Any, str] = {}
 
         self.shared_device_manager = SharedVideoDeviceManager()
 
@@ -38,16 +42,71 @@ class VideoStreamManager:
     # -----------------------
     # Public API
     # -----------------------
-    def add_stream(self, worker_source_id, url):
-        """Adds and starts a stream (regular file/RTSP or a shared direct device) if not already present."""
+    def register_stream(self, worker_source_id, url):
+        """Register a stream URL without starting it (lazy loading)."""
         with self._lock:
+            if worker_source_id not in self.pending_streams:
+                self.pending_streams[worker_source_id] = url
+                logging.debug(f"📝 Registered stream {worker_source_id} for lazy loading")
+    
+    def unregister_stream(self, worker_source_id):
+        """Unregister a stream that's no longer available in the database."""
+        with self._lock:
+            # If it's pending, remove it
+            if worker_source_id in self.pending_streams:
+                del self.pending_streams[worker_source_id]
+                logging.debug(f"🗑️ Unregistered pending stream {worker_source_id}")
+            
+            # If it's active and has no references, remove it
+            if worker_source_id in self.stream_references:
+                if len(self.stream_references[worker_source_id]) == 0:
+                    self._stop_stream(worker_source_id)
+    
+    def acquire_stream(self, worker_source_id, pipeline_id):
+        """Request access to a stream for a pipeline. Starts the stream if not already running."""
+        with self._lock:
+            # Initialize reference set if needed
+            if worker_source_id not in self.stream_references:
+                self.stream_references[worker_source_id] = set()
+            
+            # Add pipeline reference
+            self.stream_references[worker_source_id].add(pipeline_id)
+            logging.info(f"🔗 Pipeline {pipeline_id} acquired stream {worker_source_id} (refs: {len(self.stream_references[worker_source_id])})")
+            
+            # If stream is already running, we're done
             if worker_source_id in self.streams or worker_source_id in self.direct_device_streams:
-                logging.warning("⚠️ Stream %s is already active.", worker_source_id)
+                return True
+            
+            # Get URL from pending streams
+            url = self.pending_streams.get(worker_source_id)
+            if not url:
+                logging.error(f"❌ Cannot acquire stream {worker_source_id}: URL not registered")
+                return False
+        
+        # Start the stream (outside lock to avoid blocking)
+        return self._start_stream(worker_source_id, url)
+    
+    def release_stream(self, worker_source_id, pipeline_id):
+        """Release a stream reference from a pipeline. Stops the stream if no more references."""
+        with self._lock:
+            if worker_source_id not in self.stream_references:
                 return
-
+            
+            # Remove pipeline reference
+            self.stream_references[worker_source_id].discard(pipeline_id)
+            ref_count = len(self.stream_references[worker_source_id])
+            logging.info(f"🔓 Pipeline {pipeline_id} released stream {worker_source_id} (refs: {ref_count})")
+            
+            # If no more references, stop the stream
+            if ref_count == 0:
+                logging.info(f"💤 Stream {worker_source_id} has no more references, stopping...")
+                self._stop_stream(worker_source_id)
+    
+    def _start_stream(self, worker_source_id, url):
+        """Internal method to actually start a stream."""
         if self._is_direct_device(url):
             self._add_direct_device_stream(worker_source_id, url)
-            return
+            return True
 
         # Regular stream
         stream = VideoStream(url)
@@ -55,18 +114,19 @@ class VideoStreamManager:
             stream.start()  # start thread
             with self._lock:
                 self.streams[worker_source_id] = stream
-            logging.info("✅ Added and started video stream: %s", worker_source_id)
+            logging.info("✅ Started video stream: %s", worker_source_id)
+            return True
         except Exception as e:
             logging.error("❌ Failed to start regular stream %s: %s", worker_source_id, e)
-
-    def remove_stream(self, worker_source_id):
-        """Stops and removes a stream (regular or direct device)."""
-        if not worker_source_id:
-            return
-
+            return False
+    
+    def _stop_stream(self, worker_source_id):
+        """Internal method to stop a stream."""
         # Direct device?
         with self._lock:
             is_direct = worker_source_id in self.direct_device_streams
+            # Clean up references
+            self.stream_references.pop(worker_source_id, None)
 
         if is_direct:
             self._remove_direct_device_stream(worker_source_id)
@@ -77,20 +137,16 @@ class VideoStreamManager:
             stream = self.streams.pop(worker_source_id, None)
 
         if stream is None:
-            logging.warning("⚠️ Stream %s not found in manager.", worker_source_id)
             return
 
-        logging.info("🛑 Removing video stream: %s", worker_source_id)
+        logging.info("🛑 Stopping video stream: %s", worker_source_id)
         try:
-            # Expectation: VideoStream.stop() should signal and join internally.
             stream.stop()
         except Exception as e:
             logging.error("❌ Error stopping stream %s: %s", worker_source_id, e)
         finally:
             stream = None
 
-        logging.info("✅ Stream %s removed successfully.", worker_source_id)
-
     def start_all(self):
         """Starts all regular streams that are not alive. (Direct devices are publisher-driven.)"""
         logging.info("🔄 Starting all video streams...")
@@ -114,13 +170,13 @@ class VideoStreamManager:
 
         for wid in regular_ids:
             try:
-                self.remove_stream(wid)
+                self._stop_stream(wid)
             except Exception as e:
                 logging.error("Error stopping regular stream %s: %s", wid, e)
 
         for wid in direct_ids:
             try:
-                self.remove_stream(wid)
+                self._stop_stream(wid)
             except Exception as e:
                 logging.error("Error stopping direct device stream %s: %s", wid, e)
 

{nedo_vision_worker_core-0.3.4.dist-info → nedo_vision_worker_core-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedo-vision-worker-core
-Version: 0.3.4
+Version: 0.3.5
 Summary: Nedo Vision Worker Core Library for AI Vision Processing
 Author-email: Willy Achmat Fauzi <willy.achmat@gmail.com>
 Maintainer-email: Willy Achmat Fauzi <willy.achmat@gmail.com>

{nedo_vision_worker_core-0.3.4.dist-info → nedo_vision_worker_core-0.3.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-nedo_vision_worker_core/__init__.py,sha256=0iPoN0eHddv9i7aZ8YJKl2Rn_P_BTsxTJMPggoVd_kc,1924
+nedo_vision_worker_core/__init__.py,sha256=GmU149mopLuJKQ3rEY_-OetVB1aD4BIryIFVa7thDAw,1924
 nedo_vision_worker_core/cli.py,sha256=8YuKWsIgICUYXE_QtwyU3WzGhVjTWiAo5uzpFOmjNc8,5766
 nedo_vision_worker_core/core_service.py,sha256=dnHNjbslOeyeWqHDFnk_yKdfTICYzLyRIcuZNwF0Zf4,11323
 nedo_vision_worker_core/doctor.py,sha256=K_-hVV2-mdEefZ4Cfu5hMCiOxBiI1aXY8VtkkpK80Lc,10651
@@ -59,10 +59,10 @@ nedo_vision_worker_core/models/worker_source_pipeline_debug.py,sha256=6S7TkN37Fr
 nedo_vision_worker_core/models/worker_source_pipeline_detection.py,sha256=p6CJsiVCKprTYrNxJsiTB8njXdHkjZKVEyBceRVE6fY,560
 nedo_vision_worker_core/pipeline/ModelManager.py,sha256=K7lmVOo-KL7bnWtyafilZs23bzd6loCgfUz7xuAmlVw,6195
 nedo_vision_worker_core/pipeline/PipelineConfigManager.py,sha256=X55i9GyXcW9ylO6cj2UMAZFSxxPViacL4H4DZl60CAY,1157
-nedo_vision_worker_core/pipeline/PipelineManager.py,sha256=dAYLK5AXXUkfO7cyxLEGGa9SCQTP-9iAO_otffRgVsI,5482
+nedo_vision_worker_core/pipeline/PipelineManager.py,sha256=GGW3fBmDQwNcPJn5yU_BNz7hsR_H7rKoGMImCtC4T9s,6154
 nedo_vision_worker_core/pipeline/PipelinePrepocessor.py,sha256=cCiVSHHqsKCtKYURdYoEjHJX2GnT6zd8kQ6ZukjQ3V0,1271
-nedo_vision_worker_core/pipeline/PipelineProcessor.py,sha256=92ef6fRpibY3VXNeydpD1kprRCRH3fye_cpztAEVrLQ,26350
-nedo_vision_worker_core/pipeline/PipelineSyncThread.py,sha256=LX_LXU9MTdD5rP-ElHcYR431_qTXNaKOWcCsE4E9Gd0,8613
+nedo_vision_worker_core/pipeline/PipelineProcessor.py,sha256=4pAcyVpiPM8KClm6hjENQgjDbPH9_na93-ehBDGw_5U,26446
+nedo_vision_worker_core/pipeline/PipelineSyncThread.py,sha256=CAn-4F95J_VAv_7_ClrT-z9226U8ATrOGg5jOYqNuyM,8601
 nedo_vision_worker_core/pipeline/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/preprocessing/ImageResizer.py,sha256=RvOazxe6dJQuiy0ZH4lIGbdFfiu0FLUVCHoMvxkDNT4,1324
 nedo_vision_worker_core/preprocessing/ImageRoi.py,sha256=iO7oQ-SdUSA_kTIVBuq_mdycXsiJNfiFD3J7-VTxiQ4,2141
@@ -81,9 +81,9 @@ nedo_vision_worker_core/services/VideoSharingDaemon.py,sha256=iY6afEKTOsphfHvmZT
 nedo_vision_worker_core/services/VideoSharingDaemonManager.py,sha256=sc8VZo5iwoOdR8uTiel5BKz6-eZ7wwLy3IwV_3tsAu0,10340
 nedo_vision_worker_core/streams/RTMPStreamer.py,sha256=Dblfutc1UVHj159KUHFYZ8xFEVhHVknZn_nAqKR6uCs,8695
 nedo_vision_worker_core/streams/SharedVideoDeviceManager.py,sha256=vSslwxbhKH6FPndR1HcSFIVWtF-iiOQMlSa4VvFa6M4,16265
-nedo_vision_worker_core/streams/StreamSyncThread.py,sha256=WmYAY9wFiFhLlxGdnvKGIjAqLwCBayNKdmAWzkbU0jM,3763
+nedo_vision_worker_core/streams/StreamSyncThread.py,sha256=ETT0N_P90ksn6Q5pb7NvMadqCuoicz_g52lcDkHIp88,5382
 nedo_vision_worker_core/streams/VideoStream.py,sha256=nGtJ4FAZ1Ek-8hVRopEt0bLWLpa10OtyUwdDEuXLObQ,13343
-nedo_vision_worker_core/streams/VideoStreamManager.py,sha256=i7uemC3tUdsrAhL8lvoxCYa0fwUh5oAVD6DDaxflXGE,12057
+nedo_vision_worker_core/streams/VideoStreamManager.py,sha256=g5cz-YXPewSubBXxCg4mfzsuGKoOHXu-SrMxaGjYPHw,14956
 nedo_vision_worker_core/streams/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 nedo_vision_worker_core/tracker/SFSORT.py,sha256=0kggw0l4yPZ55AKHdqVX6mu9ehHmJed7jcJ3JQoC4sk,14061
 nedo_vision_worker_core/tracker/TrackerManager.py,sha256=xtDMI657W2s7HM2lMGtwU0x5Hq74BZpLHd-5xk-278I,6152
@@ -96,8 +96,8 @@ nedo_vision_worker_core/util/PersonRestrictedAreaMatcher.py,sha256=iuzCU32BQKaZ3
 nedo_vision_worker_core/util/PlatformDetector.py,sha256=GGL8UfeMQITR22EMYIRWnuOEnSqo7Dr5mb0PaFrl8AM,3006
 nedo_vision_worker_core/util/TablePrinter.py,sha256=wzLGgb1GFMeIbAP6HmKcZD33j4D-IlyqlyeR7C5yD7w,1137
 nedo_vision_worker_core/util/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
-nedo_vision_worker_core-0.3.4.dist-info/METADATA,sha256=3_UyMqyQc4m_h1qyECq1k7w3vWnN2Hr-ixnLK_BPEp0,14370
-nedo_vision_worker_core-0.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nedo_vision_worker_core-0.3.4.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
-nedo_vision_worker_core-0.3.4.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
-nedo_vision_worker_core-0.3.4.dist-info/RECORD,,
+nedo_vision_worker_core-0.3.5.dist-info/METADATA,sha256=IkDINswFijRo2j9RTaziXJdaivHiTXDe5M6X5fBAh3o,14370
+nedo_vision_worker_core-0.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nedo_vision_worker_core-0.3.5.dist-info/entry_points.txt,sha256=pIPafsvPnBw-fpBKBmc1NQCQ6PQY3ad8mZ6mn8_p5FI,70
+nedo_vision_worker_core-0.3.5.dist-info/top_level.txt,sha256=y8kusXjVYqtG8MSHYWTrk8bRrvjOrphKXYyzu943TTQ,24
+nedo_vision_worker_core-0.3.5.dist-info/RECORD,,