caption-flow 0.3.3__tar.gz → 0.3.4__tar.gz

{caption_flow-0.3.3/src/caption_flow.egg-info → caption_flow-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: caption-flow
-Version: 0.3.3
+Version: 0.3.4
 Summary: Self-contained distributed community captioning system
 Author-email: bghira <bghira@users.github.com>
 License: MIT

{caption_flow-0.3.3 → caption_flow-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "caption-flow"
-version = "0.3.3"
+version = "0.3.4"
 description = "Self-contained distributed community captioning system"
 readme = "README.md"
 requires-python = ">=3.10,<3.13"

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/__init__.py

@@ -1,6 +1,6 @@
 """CaptionFlow - Distributed community captioning system."""
 
-__version__ = "0.3.3"
+__version__ = "0.3.4"
 
 from .orchestrator import Orchestrator
 from .workers.data import DataWorker

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/cli.py

@@ -124,7 +124,7 @@ def setup_logging(verbose: bool = False):
     level = logging.DEBUG if verbose else logging.INFO
     logging.basicConfig(
         level=level,
-        format="%(message)s",
+        format="%(name)s: %(message)s",
         datefmt="[%Y-%m-%d %H:%M:%S]",
         handlers=[
             RichHandler(
@@ -490,7 +490,9 @@ def reload_config(
 
     async def send_reload():
         try:
-            async with websockets.connect(server, ssl=ssl_context) as websocket:
+            async with websockets.connect(
+                server, ssl=ssl_context, ping_interval=20, ping_timeout=60, close_timeout=10
+            ) as websocket:
                 # Authenticate as admin
                 await websocket.send(json.dumps({"token": token, "role": "admin"}))
 

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/monitor.py

@@ -73,6 +73,9 @@ class Monitor:
                 async with websockets.connect(
                     self.server_url,
                     ssl=self.ssl_context if self.server_url.startswith("wss://") else None,
+                    ping_interval=20,
+                    ping_timeout=60,
+                    close_timeout=10,
                 ) as websocket:
                     # Authenticate
                     await websocket.send(json.dumps({"token": self.token}))

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/orchestrator.py

@@ -377,16 +377,17 @@ class Orchestrator:
         """Process results submission from worker."""
         # Extract user from worker_id
         worker_user = worker_id.rsplit("_", 1)[0] if "_" in worker_id else worker_id
+
         # Create work result
         _job_id = data.get("job_id")
         job_id = JobId.from_str(_job_id)
-        shard_name = job_id.shard_id  # >data-0000<
-        chunk_name = job_id.chunk_id  # data-0000:chunk:>0<
-        # logger.debug(f"({job_id}) Worker result: {data}")
+        shard_name = job_id.shard_id
+        chunk_name = job_id.chunk_id
+
         result = WorkResult(
             unit_id=data["unit_id"],
             source_id=shard_name,
-            chunk_id=job_id.get_chunk_str(),  # we want the full string here
+            chunk_id=job_id.get_chunk_str(),
             sample_id=data["sample_id"],
             dataset=data["dataset"],
             outputs=data["outputs"],
@@ -394,7 +395,9 @@ class Orchestrator:
             processing_time_ms=data.get("processing_time_ms", 0),
         )
 
-        # Let processor handle any custom processing
+        # Let processor handle any custom processing - this updates chunk tracker
+        # IMPORTANT: Call this BEFORE saving to storage so chunk tracker is updated
+        # regardless of whether the item is a duplicate
         processed = self.processor.handle_result(result)
 
         # Create caption record for storage
@@ -412,6 +415,7 @@ class Orchestrator:
         for key in to_delete_metadata_keys:
             if key in result.metadata:
                 del result.metadata[key]
+
         caption = Caption(
             job_id=job_id,
             dataset=result.dataset,
@@ -433,14 +437,15 @@ class Orchestrator:
             image_format=image_format,
         )
 
-        # Save to storage
-        await self.storage.save_caption(caption)
+        # Save to storage (might skip if duplicate)
+        saved = await self.storage.save_caption(caption)
 
-        # Update contributor stats
-        contributor = await self.storage.get_contributor(worker_user)
-        if contributor:
-            contributor.total_captions += total_outputs
-            await self.storage.save_contributor(contributor)
+        # Update contributor stats only if actually saved
+        if saved:
+            contributor = await self.storage.get_contributor(worker_user)
+            if contributor:
+                contributor.total_captions += total_outputs
+                await self.storage.save_contributor(contributor)
 
     async def _handle_monitor(self, websocket: WebSocketServerProtocol):
         """Handle monitor connection."""
@@ -840,39 +845,55 @@ class Orchestrator:
         self.monitors -= disconnected
 
     async def _heartbeat_loop(self):
-        """Send periodic heartbeats to maintain connections."""
+        """Collect and log worker status periodically."""
         while True:
             await asyncio.sleep(30)
 
-            disconnected = []
+            # Just collect status - no ping/pong
+            active_workers = []
             for worker_id, ws in list(self.workers.items()):
-                try:
-                    pong_waiter = await ws.ping()
-                    await asyncio.wait_for(pong_waiter, timeout=10)
-                except:
-                    disconnected.append(worker_id)
-
-            # Clean up disconnected workers
-            for worker_id in disconnected:
-                logger.warning(f"Worker {worker_id} did not respond to ping, disconnecting")
-                if worker_id in self.workers:
+                # Check if WebSocket is still open (don't ping)
+                if ws.state == websockets.protocol.State.OPEN:
+                    active_workers.append(worker_id)
+                else:
+                    # Clean up closed connections
+                    logger.info(f"Worker {worker_id} connection closed")
                     del self.workers[worker_id]
-                    logger.warning(
-                        f"Releasing assignments for worker {worker_id} because it did not respond to ping"
-                    )
                     self.processor.release_assignments(worker_id)
-                    self.stats["connected_workers"] = len(self.workers)
+
+            # Log status
+            if active_workers:
+                logger.debug(
+                    f"Active workers: {len(active_workers)} - {', '.join(active_workers[:5])}"
+                )
+                logger.debug(f"Inactive workers: {len(self.workers) - len(active_workers)}")
+            # add to self.stats
+            self.stats["active_workers"] = len(active_workers)
+            self.stats["inactive_workers"] = len(self.workers) - len(active_workers)
 
     async def _checkpoint_loop(self):
-        """Periodically checkpoint storage."""
+        """Periodically checkpoint storage and chunk tracker."""
         interval = self.config.get("storage", {}).get("checkpoint_interval", 60)
 
         while True:
             await asyncio.sleep(interval)
 
-            await self.storage.checkpoint()
-            self.stats["last_checkpoint"] = datetime.utcnow().isoformat()
-            logger.info("Storage checkpoint complete")
+            try:
+                # Checkpoint storage
+                await self.storage.checkpoint()
+
+                # Also checkpoint the chunk tracker if using webdataset processor
+                if hasattr(self.processor, "chunk_tracker") and self.processor.chunk_tracker:
+                    # Save checkpoint in thread pool to avoid blocking
+                    await asyncio.get_event_loop().run_in_executor(
+                        None, self.processor.chunk_tracker.save
+                    )
+                    logger.debug("Saved chunk tracker checkpoint")
+
+                self.stats["last_checkpoint"] = datetime.utcnow().isoformat()
+                logger.info("Storage and chunk tracker checkpoint complete")
+            except Exception as e:
+                logger.error(f"Error during checkpoint: {e}", exc_info=True)
 
     async def _stats_update_loop(self):
         """Periodically update and broadcast stats."""

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/processors/huggingface.py

@@ -551,7 +551,7 @@ class HuggingFaceDatasetOrchestratorProcessor(OrchestratorProcessor):
 
             # Force checkpoint save if needed
             if self.chunk_tracker:
-                self.chunk_tracker.save_checkpoint()
+                self.chunk_tracker.save()
 
     def get_work_units(self, count: int, worker_id: str) -> List[WorkUnit]:
         """Get available work units for a worker."""
@@ -717,7 +717,7 @@ class HuggingFaceDatasetOrchestratorProcessor(OrchestratorProcessor):
 
         # Save final state
         if self.chunk_tracker:
-            self.chunk_tracker.save_checkpoint()
+            self.chunk_tracker.save()
 
 
 class HuggingFaceDatasetWorkerProcessor(WorkerProcessor):

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/processors/webdataset.py

@@ -306,8 +306,15 @@ class WebDatasetOrchestratorProcessor(OrchestratorProcessor):
         assigned = []
 
         with self.lock:
-            while len(assigned) < count and self.pending_units:
+            units_checked = 0
+            max_units_to_check = len(self.pending_units)
+
+            while len(assigned) < count and units_checked < max_units_to_check:
+                if not self.pending_units:
+                    break
+
                 unit_id = self.pending_units.popleft()
+                units_checked += 1
                 unit = self.work_units.get(unit_id)
 
                 if unit:
@@ -316,6 +323,16 @@ class WebDatasetOrchestratorProcessor(OrchestratorProcessor):
                         chunk_state = self.chunk_tracker.chunks[unit_id]
                         relative_unprocessed = chunk_state.get_unprocessed_ranges()
 
+                        # If no unprocessed ranges, mark as completed and skip
+                        if not relative_unprocessed:
+                            logger.info(
+                                f"Chunk {unit_id} has no unprocessed ranges, marking as completed"
+                            )
+                            self.chunk_tracker.mark_completed(unit_id)
+                            # Remove from work units
+                            del self.work_units[unit_id]
+                            continue
+
                         # Convert relative to absolute indices
                         absolute_ranges = []
                         for start, end in relative_unprocessed:
@@ -335,6 +352,9 @@ class WebDatasetOrchestratorProcessor(OrchestratorProcessor):
 
                     if self.chunk_tracker:
                         self.chunk_tracker.mark_assigned(unit_id, worker_id)
+                else:
+                    # Put it back if we couldn't get the unit
+                    self.pending_units.append(unit_id)
 
         logger.debug(f"Assigned {len(assigned)} units to worker {worker_id}")
         return assigned
@@ -394,8 +414,20 @@ class WebDatasetOrchestratorProcessor(OrchestratorProcessor):
         logger.info(f"Released {len(unit_ids)} assignments from {worker_id}")
 
     def handle_result(self, result: WorkResult) -> Dict[str, Any]:
-        """Handle result from worker."""
-        # Track processed items if we have chunk tracker
+        """Handle result from worker and update chunk tracker."""
+        # Extract the actual item index from the metadata
+        item_index = result.metadata.get("_item_index", None)
+
+        # If we have an item index, mark it as processed in the chunk tracker
+        if self.chunk_tracker and item_index is not None and result.chunk_id:
+            try:
+                # Mark single item as processed
+                self.chunk_tracker.mark_items_processed(result.chunk_id, item_index, item_index)
+                # logger.debug(f"Marked item {item_index} as processed in chunk {result.chunk_id}")
+            except Exception as e:
+                logger.error(f"Error marking item {item_index} as processed: {e}")
+
+        # Also handle batch results if present (backward compatibility)
         if self.chunk_tracker and "item_indices" in result.metadata:
             indices = result.metadata["item_indices"]
 
@@ -419,6 +451,9 @@ class WebDatasetOrchestratorProcessor(OrchestratorProcessor):
                 # Mark ranges as processed
                 for start_idx, end_idx in ranges:
                     self.chunk_tracker.mark_items_processed(result.chunk_id, start_idx, end_idx)
+                    logger.debug(
+                        f"Marked range {start_idx}-{end_idx} as processed in chunk {result.chunk_id}"
+                    )
 
         return {
             "source_id": result.source_id,
@@ -539,7 +574,7 @@ class WebDatasetOrchestratorProcessor(OrchestratorProcessor):
 
         # Save checkpoint
         if self.chunk_tracker:
-            self.chunk_tracker.save_checkpoint()
+            self.chunk_tracker.save()
 
 
 class WebDatasetWorkerProcessor(WorkerProcessor):

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/utils/checkpoint_tracker.py

@@ -6,6 +6,7 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Dict, Any, Optional
 from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor
 
 logger = logging.getLogger(__name__)
 
@@ -52,35 +53,54 @@ class CheckpointTracker(ABC):
 
     def save(self) -> None:
         """Save checkpoint to disk atomically."""
-        try:
-            # Prepare data with metadata
-            data = self._serialize_state()
-            data["updated_at"] = datetime.utcnow().isoformat()
+        with self.lock:
+            try:
+                # Prepare data with metadata
+                data = self._serialize_state()
+                data["updated_at"] = datetime.utcnow().isoformat()
+
+                # Write atomically using temp file
+                tmp_file = self.checkpoint_path.with_suffix(".tmp")
+                # If a save is already in progress, let it finish.
+                # This prevents race conditions if save() is called rapidly.
+                if (
+                    hasattr(self, "_save_future")
+                    and self._save_future
+                    and not self._save_future.done()
+                ):
+                    self._save_future.result()  # Wait for the previous save to complete
+
+                # Use an executor to run the save operation in a background thread.
+                # This makes the save call non-blocking.
+                with ThreadPoolExecutor(max_workers=1) as executor:
+                    data_to_save = data.copy()
+                    self._save_future = executor.submit(self._write_to_disk, data_to_save, tmp_file)
+            except Exception as e:
+                logger.error(f"Failed to submit save task: {e}", exc_info=True)
 
-            # Write atomically using temp file
-            tmp_file = self.checkpoint_path.with_suffix(".tmp")
+    def _write_to_disk(self, data: Dict[str, Any]) -> None:
+        """Write checkpoint data to disk atomically."""
+        # Create a temporary file in the same directory as the checkpoint
+        tmp_file = self.checkpoint_path.with_suffix(".tmp")
+
+        try:
+            # Ensure the parent directory exists
+            self.checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
 
             with open(tmp_file, "w") as f:
                 json.dump(data, f, indent=2)
 
-            # Ensure temp file was created
-            if not tmp_file.exists():
-                raise IOError(f"Failed to create temporary file: {tmp_file}")
-
-            # Move atomically
+            # Atomically replace the checkpoint file
             tmp_file.replace(self.checkpoint_path)
-
             logger.debug(f"Saved checkpoint to {self.checkpoint_path}")
-
         except Exception as e:
-            # logger.error(f"Error saving checkpoint: {e}", exc_info=True)
-            # Try direct write as fallback
-            try:
-                with open(self.checkpoint_path, "w") as f:
-                    json.dump(data, f, indent=2)
-                # logger.info("Saved checkpoint using fallback direct write")
-            except Exception as fallback_error:
-                logger.error(f"Fallback save also failed: {fallback_error}")
+            logger.error(f"Failed to save checkpoint atomically: {e}", exc_info=True)
+            # Try to clean up the temp file if it exists
+            if tmp_file.exists():
+                try:
+                    tmp_file.unlink()
+                except:
+                    pass
 
     def get_stats(self) -> Dict[str, Any]:
         """Get statistics about tracked items. Override for custom stats."""

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/utils/chunk_tracker.py

@@ -8,6 +8,7 @@ from datetime import datetime, timedelta
 from dataclasses import dataclass, asdict, field
 
 from .checkpoint_tracker import CheckpointTracker
+from threading import Lock
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
@@ -60,12 +61,12 @@ class ChunkState:
         self.status = "completed"
         self.completed_at = datetime.utcnow()
         # Clear processed_ranges since we don't need them after completion
-        self.processed_ranges = []
-        self.assigned_to = None
-        self.assigned_at = None
+        # self.processed_ranges = []
+        # self.assigned_to = None
+        # self.assigned_at = None
 
     def get_unprocessed_ranges(self) -> List[Tuple[int, int]]:
-        """Get ranges that haven't been processed yet."""
+        """Get ranges of unprocessed items within the chunk (relative indices)."""
         if self.status == "completed":
             return []
 
@@ -73,22 +74,57 @@ class ChunkState:
             logger.info(f"Chunk {self.chunk_id} has no processed ranges, returning full range")
             return [(0, self.chunk_size - 1)]
 
+        # Merge ranges first to ensure no overlaps
+        merged_ranges = self._merge_ranges(self.processed_ranges)
+
         unprocessed = []
-        current = 0
+        current_pos = 0
 
-        logger.info(
-            f"Processing {len(self.processed_ranges)} processed ranges for chunk {self.chunk_id}"
-        )
-        for start, end in self.processed_ranges:
-            if current < start:
-                unprocessed.append((current, start - 1))
-            current = max(current, end + 1)
+        for start, end in merged_ranges:
+            if current_pos < start:
+                unprocessed.append((current_pos, start - 1))
+            current_pos = max(current_pos, end + 1)
 
-        if current < self.chunk_size:
-            unprocessed.append((current, self.chunk_size - 1))
+        # Add any remaining range
+        if current_pos < self.chunk_size:
+            unprocessed.append((current_pos, self.chunk_size - 1))
+
+        # Log for debugging
+        if not unprocessed:
+            logger.info(
+                f"Chunk {self.chunk_id} has processed ranges {merged_ranges} covering entire chunk size {self.chunk_size}"
+            )
+        else:
+            total_processed = sum(end - start + 1 for start, end in merged_ranges)
+            total_unprocessed = sum(end - start + 1 for start, end in unprocessed)
+            logger.debug(
+                f"Chunk {self.chunk_id}: {total_processed} processed, {total_unprocessed} unprocessed"
+            )
 
         return unprocessed
 
+    def _merge_ranges(self, ranges: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
+        """Merge overlapping or adjacent ranges."""
+        if not ranges:
+            return []
+
+        # Sort ranges by start index, ensuring all are tuples
+        sorted_ranges = sorted([tuple(r) for r in ranges])
+        merged = [sorted_ranges[0]]
+
+        for current_start, current_end in sorted_ranges[1:]:
+            last_start, last_end = merged[-1]
+
+            # Check if ranges overlap or are adjacent
+            if current_start <= last_end + 1:
+                # Merge the ranges
+                merged[-1] = (last_start, max(last_end, current_end))
+            else:
+                # Add as new range
+                merged.append((current_start, current_end))
+
+        return merged
+
     def to_dict(self):
         """Convert to dictionary for JSON serialization."""
         d = asdict(self)
@@ -124,6 +160,7 @@ class ChunkTracker(CheckpointTracker):
         self.max_completed_chunks_in_memory = max_completed_chunks_in_memory
         self.archive_after_hours = archive_after_hours
         self._completed_count = 0  # Track count without storing all IDs
+        self.lock = Lock()
         super().__init__(checkpoint_file)
 
     def _get_default_state(self) -> Dict[str, Any]:
@@ -132,16 +169,17 @@ class ChunkTracker(CheckpointTracker):
 
     def _deserialize_state(self, data: Dict[str, Any]) -> None:
         """Deserialize loaded data into instance state."""
-        self.chunks = {}
-        self._completed_count = data.get("completed_count", 0)
-
-        # Load chunk states
-        completed_chunks = 0
-        for chunk_id, chunk_data in data.get("chunks", {}).items():
-            chunk_state = ChunkState.from_dict(chunk_data)
-            self.chunks[chunk_id] = chunk_state
-            if chunk_state.status == "completed":
-                completed_chunks += 1
+        with self.lock:
+            self.chunks = {}
+            self._completed_count = data.get("completed_count", 0)
+
+            # Load chunk states
+            completed_chunks = 0
+            for chunk_id, chunk_data in data.get("chunks", {}).items():
+                chunk_state = ChunkState.from_dict(chunk_data)
+                self.chunks[chunk_id] = chunk_state
+                if chunk_state.status == "completed":
+                    completed_chunks += 1
 
         logger.info(
             f"Loaded {len(self.chunks)} chunks from checkpoint, "
@@ -494,40 +532,40 @@ class ChunkTracker(CheckpointTracker):
                 for start_idx, end_idx in ranges:
                     chunk.add_processed_range(start_idx, end_idx)
 
-    def mark_items_processed(self, chunk_id: str, start_idx: int, end_idx: int):
-        """Mark a range of items as processed within a chunk (expects ABSOLUTE indices)."""
+    def mark_items_processed(self, chunk_id: str, start_idx: int, end_idx: int) -> None:
+        """Mark a range of items as processed within a chunk."""
         if chunk_id not in self.chunks:
-            logger.error(f"Unknown chunk: {chunk_id}")
+            logger.warning(f"Chunk {chunk_id} not found in tracker")
             return
 
-        chunk = self.chunks[chunk_id]
+        chunk_state = self.chunks[chunk_id]
 
-        # Convert absolute indices to chunk-relative
-        relative_start = start_idx - chunk.start_index
-        relative_end = end_idx - chunk.start_index
+        # Convert absolute indices to chunk-relative indices
+        relative_start = start_idx - chunk_state.start_index
+        relative_end = end_idx - chunk_state.start_index
 
-        # Validate boundaries
-        if relative_start < 0 or relative_end >= chunk.chunk_size:
-            logger.error(
-                f"Invalid indices for chunk {chunk_id}: "
-                f"absolute {start_idx}-{end_idx} (relative {relative_start}-{relative_end}) "
-                f"outside chunk bounds [{chunk.start_index}, {chunk.start_index + chunk.chunk_size - 1}]"
-            )
-            return
+        # Ensure indices are within chunk bounds
+        relative_start = max(0, relative_start)
+        relative_end = min(chunk_state.chunk_size - 1, relative_end)
 
-        # Add the relative range
-        chunk.add_processed_range(relative_start, relative_end)
+        # Add to processed ranges
+        chunk_state.processed_ranges.append((relative_start, relative_end))
 
-        # If chunk is now complete, increment counter
-        if chunk.status == "completed":
-            self._completed_count += 1
+        # Merge overlapping ranges
+        chunk_state.processed_ranges = chunk_state._merge_ranges(chunk_state.processed_ranges)
 
-        self.save()
         logger.debug(
-            f"Marked items {start_idx}-{end_idx} as processed in chunk {chunk_id} "
-            f"(relative indices: {relative_start}-{relative_end})"
+            f"Marked items {start_idx}-{end_idx} as processed in chunk {chunk_id} (relative indices: {relative_start}-{relative_end})"
         )
 
+        # Check if chunk is now complete
+        if chunk_state.get_unprocessed_ranges() == []:
+            logger.info(f"Chunk {chunk_id} is now complete")
+            chunk_state.status = "completed"
+
+        # Save checkpoint after updating
+        self.save()
+
     def get_chunk_with_unprocessed_items(self, chunk_id: str) -> Optional[Dict[str, Any]]:
         """Get chunk info with unprocessed item ranges."""
         chunk_state = self.chunks.get(chunk_id)

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/workers/base.py

@@ -89,8 +89,13 @@ class BaseWorker(ABC):
     async def _connect_and_run(self):
         """Connect to orchestrator and run main loop."""
         logger.info(f"Connecting to {self.server_url}")
-
-        async with websockets.connect(self.server_url, ssl=self.ssl_context) as websocket:
+        async with websockets.connect(
+            self.server_url,
+            ssl=self.ssl_context,
+            ping_interval=20,
+            ping_timeout=60,
+            close_timeout=10,
+        ) as websocket:
             self.websocket = websocket
             self.connected.set()
 

{caption_flow-0.3.3 → caption_flow-0.3.4}/src/caption_flow/workers/caption.py

@@ -248,7 +248,13 @@ class CaptionWorker(BaseWorker):
     async def _initial_connect_for_config(self):
         """Connect initially just to get configuration."""
         logger.info(f"Connecting to {self.server_url}")
-        async with websockets.connect(self.server_url, ssl=self.ssl_context) as websocket:
+        async with websockets.connect(
+            self.server_url,
+            ssl=self.ssl_context,
+            ping_interval=20,
+            ping_timeout=60,
+            close_timeout=10,
+        ) as websocket:
             await websocket.send(json.dumps(self._get_auth_data()))
 
             welcome = await websocket.recv()

{caption_flow-0.3.3 → caption_flow-0.3.4/src/caption_flow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: caption-flow
-Version: 0.3.3
+Version: 0.3.4
 Summary: Self-contained distributed community captioning system
 Author-email: bghira <bghira@users.github.com>
 License: MIT