caption-flow 0.3.4__py3-none-any.whl → 0.4.1__py3-none-any.whl

caption_flow/workers/caption.py

@@ -7,34 +7,34 @@ os.environ["VLLM_ENABLE_V1_MULTIPROCESSING"] = "0"
 import asyncio
 import json
 import logging
-import websockets
 import time
-from dataclasses import dataclass
-from typing import Dict, Any, Optional, List, Tuple, Union
-from queue import Queue, Empty
-from threading import Thread, Event, Lock
 from collections import defaultdict, deque
+from dataclasses import dataclass
+from queue import Empty, Queue
+from threading import Event, Lock, Thread
+from typing import Any, Dict, List, Optional, Tuple, Union
 
-from PIL import Image
+import websockets
 from huggingface_hub import get_token
+from PIL import Image
 
-from .base import BaseWorker
+from ..models import ProcessingStage, StageResult
 from ..processors import (
+    HuggingFaceDatasetWorkerProcessor,
+    LocalFilesystemWorkerProcessor,
     ProcessorConfig,
+    WebDatasetWorkerProcessor,
     WorkAssignment,
-    WorkUnit,
     WorkResult,
-    WebDatasetWorkerProcessor,
-    HuggingFaceDatasetWorkerProcessor,
-    LocalFilesystemWorkerProcessor,
+    WorkUnit,
 )
-from ..utils.vllm_config import VLLMConfigManager
 from ..utils.image_processor import ImageProcessor
 from ..utils.prompt_template import PromptTemplateManager
-from ..models import ProcessingStage, StageResult
+from ..utils.vllm_config import VLLMConfigManager
+from .base import BaseWorker
 
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
+logger.setLevel(os.environ.get("CAPTIONFLOW_LOG_LEVEL", "INFO").upper())
 
 
 @dataclass
@@ -72,8 +72,8 @@ class MultiStageVLLMManager:
             logger.info(f"Model {model_name} already loaded, reusing instance")
             return
 
-        from vllm import LLM, SamplingParams
-        from transformers import AutoTokenizer, AutoProcessor
+        from transformers import AutoProcessor, AutoTokenizer
+        from vllm import LLM
 
         logger.info(f"Loading model {model_name} for stage {stage.name}")
 
@@ -137,6 +137,19 @@ class MultiStageVLLMManager:
 
     def get_model_for_stage(self, stage_name: str, model_name: str) -> Tuple[Any, Any, Any, Any]:
         """Get model components for a stage."""
+        if model_name not in self.models:
+            raise KeyError(
+                f"Model '{model_name}' not found in loaded models. Available models: {list(self.models.keys())}"
+            )
+        if model_name not in self.processors:
+            raise KeyError(f"Processor for model '{model_name}' not found")
+        if model_name not in self.tokenizers:
+            raise KeyError(f"Tokenizer for model '{model_name}' not found")
+        if stage_name not in self.sampling_params:
+            raise KeyError(
+                f"Sampling params for stage '{stage_name}' not found. Available stages: {list(self.sampling_params.keys())}"
+            )
+
         return (
             self.models[model_name],
             self.processors[model_name],
@@ -305,7 +318,7 @@ class CaptionWorker(BaseWorker):
             self.processor = LocalFilesystemWorkerProcessor()
         else:
             raise ValueError(f"Unknown processor type: {self.processor_type}")
-
+        self.processor.gpu_id = self.gpu_id
         self.processor.initialize(processor_config)
         self.dataset_path = self.processor.dataset_path
         self.units_per_request = processor_config.config.get("chunks_per_request", 1)
@@ -463,7 +476,7 @@ class CaptionWorker(BaseWorker):
         # Check if stages changed significantly
         stages_changed = len(new_stages) != len(self.stages)
         if not stages_changed:
-            for old, new in zip(self.stages, new_stages):
+            for old, new in zip(self.stages, new_stages, strict=False):
                 if (
                     old.name != new.name
                     or old.model != new.model
@@ -489,7 +502,19 @@ class CaptionWorker(BaseWorker):
                     return True
                 except Exception as e:
                     logger.error(f"Failed to reload vLLM: {e}")
+                    # Restore previous state
                     self.vllm_config = old_config
+                    self.stages = self._parse_stages_config(old_config)
+                    self.stage_order = self._topological_sort_stages(self.stages)
+                    # Attempt to restore previous models
+                    try:
+                        self._setup_vllm()
+                    except Exception as restore_error:
+                        logger.error(f"Failed to restore previous vLLM state: {restore_error}")
+                        # Clean up broken state
+                        if self.model_manager:
+                            self.model_manager.cleanup()
+                            self.model_manager = None
                     return False
             else:
                 # Clean up models if switching to mock mode
@@ -580,6 +605,7 @@ class CaptionWorker(BaseWorker):
 
             try:
                 # Create processing item
+                logger.debug(f"Processing item data: {item_data}")
                 item = ProcessingItem(
                     unit_id=unit.unit_id,
                     chunk_id=unit.chunk_id,
@@ -610,34 +636,64 @@ class CaptionWorker(BaseWorker):
         if batch and not self.should_stop_processing.is_set():
             self._process_batch(batch)
 
-        # Notify orchestrator that unit is complete
+        # Notify orchestrator about unit completion or failure
         # Check if the number of processed items matches the expected count for the unit.
         # The context dictionary holds the count of items yielded by the processor.
         total_items_in_unit = unit.unit_size
 
-        if (
-            not self.should_stop_processing.is_set()
-            and self.connected.is_set()
-            and self.items_failed == 0
-            and self.items_processed >= total_items_in_unit
-        ):
-            if self.websocket:
-                try:
-                    asyncio.run_coroutine_threadsafe(
-                        self.websocket.send(
-                            json.dumps({"type": "work_complete", "unit_id": unit.unit_id})
-                        ),
-                        self.main_loop,
-                    ).result(timeout=5)
-                    logger.info(
-                        f"Unit {unit.unit_id} fully processed ({self.items_processed}/{total_items_in_unit}) and marked complete."
+        if not self.should_stop_processing.is_set() and self.connected.is_set():
+            if self.items_failed == 0 and self.items_processed >= total_items_in_unit:
+                # Unit completed successfully
+                if self.websocket:
+                    try:
+                        asyncio.run_coroutine_threadsafe(
+                            self.websocket.send(
+                                json.dumps({"type": "work_complete", "unit_id": unit.unit_id})
+                            ),
+                            self.main_loop,
+                        ).result(timeout=5)
+                        logger.info(
+                            f"Unit {unit.unit_id} fully processed "
+                            f"({self.items_processed}/{total_items_in_unit}) and marked complete."
+                        )
+                    except Exception as e:
+                        logger.warning(
+                            f"Could not notify work complete for unit {unit.unit_id}: {e}"
+                        )
+            else:
+                # Unit failed or was incomplete
+                if self.items_failed > 0:
+                    error_msg = (
+                        f"Processing failed for {self.items_failed} out of "
+                        f"{total_items_in_unit} items"
                     )
-                except Exception as e:
-                    logger.warning(f"Could not notify work complete for unit {unit.unit_id}: {e}")
+                    logger.error(f"Unit {unit.unit_id} failed: {error_msg}")
+                else:
+                    error_msg = (
+                        f"Processing incomplete: {self.items_processed}/"
+                        f"{total_items_in_unit} items processed"
+                    )
+                    logger.warning(f"Unit {unit.unit_id} incomplete: {error_msg}")
+
+                if self.websocket:
+                    try:
+                        asyncio.run_coroutine_threadsafe(
+                            self.websocket.send(
+                                json.dumps(
+                                    {
+                                        "type": "work_failed",
+                                        "unit_id": unit.unit_id,
+                                        "error": error_msg,
+                                    }
+                                )
+                            ),
+                            self.main_loop,
+                        ).result(timeout=5)
+                        logger.info(f"Unit {unit.unit_id} failure reported to orchestrator")
+                    except Exception as e:
+                        logger.warning(f"Could not notify work failed for unit {unit.unit_id}: {e}")
         else:
-            logger.warning(
-                f"Processing of unit {unit.unit_id} was incomplete ({self.items_processed}/{total_items_in_unit}). Not marking as complete."
-            )
+            logger.info(f"Unit {unit.unit_id} processing stopped due to disconnect or shutdown")
 
     def _process_batch(self, batch: List[ProcessingItem]):
         """Process a batch of items through all stages."""
@@ -672,6 +728,20 @@ class CaptionWorker(BaseWorker):
         except Exception as e:
             logger.error(f"Batch processing error: {e}", exc_info=True)
 
+            # Mark all items in batch as failed
+            self.items_failed += len(batch)
+
+            # Send error results for each item in the batch
+            for item in batch:
+                self.result_queue.put(
+                    {
+                        "item": item,
+                        "outputs": {},
+                        "processing_time_ms": 0.0,
+                        "error": f"Batch processing failed: {str(e)}",
+                    }
+                )
+
     def _process_batch_mock(self, batch: List[ProcessingItem]) -> List[Tuple[ProcessingItem, Dict]]:
         """Process a batch in mock mode - return dummy captions."""
         results = []
@@ -686,9 +756,9 @@ class CaptionWorker(BaseWorker):
 
                 # Create mock outputs based on stage prompts
                 stage_outputs = []
-                for i, prompt in enumerate(stage.prompts):
+                for i, _prompt in enumerate(stage.prompts):
                     mock_output = (
-                        f"Mock {stage_name} output {i+1} for job {item.job_id} - {item.item_key}"
+                        f"Mock {stage_name} output {i + 1} for job {item.job_id} - {item.item_key}"
                     )
                     stage_outputs.append(mock_output)
 
@@ -713,42 +783,212 @@ class CaptionWorker(BaseWorker):
 
         return results
 
+    def _validate_and_split_batch(
+        self,
+        batch: List[ProcessingItem],
+        stage: ProcessingStage,
+        processor,
+        tokenizer,
+        sampling_params,
+        max_length: int = 16384,
+    ) -> Tuple[List[ProcessingItem], List[ProcessingItem]]:
+        """Validate batch items and split into processable and too-long items."""
+        logger.debug(
+            f"Validating batch of size {len(batch)} for stage '{stage.name}' "
+            f"with max_length {max_length}"
+        )
+        processable = []
+        too_long = []
+
+        for item in batch:
+            try:
+                # Create a test prompt for this item
+                converted_img = ImageProcessor.prepare_for_inference(item)
+                template_manager = PromptTemplateManager(
+                    stage.prompts[:1]
+                )  # Test with first prompt
+
+                # Build context
+                context = item.metadata.copy()
+                for prev_stage_name, stage_result in item.stage_results.items():
+                    for i, output in enumerate(stage_result.outputs):
+                        context[f"{prev_stage_name}_output_{i}"] = output
+                    if len(stage_result.outputs) == 1:
+                        context[stage_result.output_field] = stage_result.outputs[0]
+                    else:
+                        context[stage_result.output_field] = stage_result.outputs
+                logger.debug(f"Validation context for {item.item_key}: {context}")
+
+                # Format test prompt
+                formatted_prompts = template_manager.format_all(context)
+                if not formatted_prompts:
+                    logger.warning(
+                        f"Could not format prompt for {item.item_key}, marking as too long."
+                    )
+                    too_long.append(item)
+                    continue
+
+                logger.debug(
+                    f"Formatted validation prompt for {item.item_key}: {formatted_prompts[0]}"
+                )
+
+                # Build actual vLLM input to test
+                test_req = self._build_vllm_input(
+                    converted_img, formatted_prompts[0], processor, tokenizer
+                )
+
+                # Use processor to get actual token count
+                if "prompt_token_ids" in test_req:
+                    prompt_length = len(test_req["prompt_token_ids"])
+                else:
+                    # Fallback to tokenizer
+                    prompt_length = len(tokenizer.encode(test_req.get("prompt", "")))
+
+                # Check individual prompt length (prompts are processed one by one)
+                # Use a small safety buffer to account for token estimation variations
+                safety_buffer = 50
+                if prompt_length < max_length - safety_buffer:
+                    processable.append(item)
+                    logger.debug(
+                        f"Item {item.item_key} validated: {prompt_length} tokens per prompt"
+                    )
+                else:
+                    too_long.append(item)
+                    logger.warning(
+                        f"Item {item.item_key} too long: {prompt_length} tokens "
+                        f"vs max {max_length - safety_buffer} (with safety buffer)"
+                    )
+
+            except Exception as e:
+                logger.error(f"Error validating item {item.item_key}: {e}", exc_info=True)
+                too_long.append(item)
+
+        logger.debug(
+            f"Validation complete: {len(processable)} processable, {len(too_long)} too long."
+        )
+        return processable, too_long
+
+    def _resize_image_for_tokens(
+        self, item: ProcessingItem, target_ratio: float = 0.7
+    ) -> ProcessingItem:
+        """Resize image to reduce token count."""
+        if not item.image:
+            return item
+
+        # Calculate new size
+        new_width = int(item.image.width * target_ratio)
+        new_height = int(item.image.height * target_ratio)
+
+        # Resize image
+        resized_image = item.image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+        # Create new item with resized image
+        new_item = ProcessingItem(
+            unit_id=item.unit_id,
+            job_id=item.job_id,
+            chunk_id=item.chunk_id,
+            item_key=item.item_key,
+            item_index=item.item_index,
+            image=resized_image,
+            image_data=item.image_data,  # Keep original data for metadata
+            metadata={**item.metadata, "_resized": True, "_resize_ratio": target_ratio},
+            stage_results=item.stage_results.copy(),
+        )
+
+        return new_item
+
     def _process_batch_multi_stage(
         self, batch: List[ProcessingItem], max_attempts: int = 3
     ) -> List[Tuple[ProcessingItem, Dict]]:
-        """Process a batch through all stages sequentially."""
+        """Process a batch through all stages with token validation."""
         results = []
 
+        # Get max model length from config
+        max_model_len = self.vllm_config.get("max_model_len", 16384)
+
         # Process each stage in order
         for stage_name in self.stage_order:
             stage = next(s for s in self.stages if s.name == stage_name)
             logger.debug(f"Processing batch through stage: {stage_name}")
 
+            # Check if model manager is properly initialized
+            if not self.model_manager:
+                logger.error("Model manager not initialized")
+                self.items_failed += len(batch)
+                return []
+
             # Get model components
-            llm, processor, tokenizer, sampling_params = self.model_manager.get_model_for_stage(
-                stage_name, stage.model
+            try:
+                llm, processor, tokenizer, sampling_params = self.model_manager.get_model_for_stage(
+                    stage_name, stage.model
+                )
+            except KeyError as e:
+                logger.error(f"Model not found during batch processing: {e}")
+                self.items_failed += len(batch)
+                return []
+
+            # Validate batch before processing
+            processable_batch, too_long_items = self._validate_and_split_batch(
+                batch, stage, processor, tokenizer, sampling_params, max_model_len
             )
 
-            # Track items for retry
-            items_to_process = [(i, item, 0) for i, item in enumerate(batch)]
+            # Handle items that are too long
+            for item in too_long_items:
+                logger.warning(f"Item {item.item_key} exceeds token limit, attempting resize")
 
-            while items_to_process:
-                current_batch = []
-                requests = []
+                # Try resizing the image
+                resized_item = self._resize_image_for_tokens(item, target_ratio=0.7)
 
-                for idx, (original_idx, item, attempt_count) in enumerate(items_to_process):
-                    current_batch.append((original_idx, item, attempt_count))
+                # Re-validate
+                resized_processable, still_too_long = self._validate_and_split_batch(
+                    [resized_item], stage, processor, tokenizer, sampling_params, max_model_len
+                )
 
-                    # Prepare image from PIL frame or bytes
-                    converted_img = ImageProcessor.prepare_for_inference(item)
+                if resized_processable:
+                    processable_batch.extend(resized_processable)
+                    logger.info(f"Successfully resized {item.item_key} for processing")
+                else:
+                    # Try even smaller
+                    resized_item = self._resize_image_for_tokens(item, target_ratio=0.5)
+                    resized_processable, still_too_long = self._validate_and_split_batch(
+                        [resized_item], stage, processor, tokenizer, sampling_params, max_model_len
+                    )
+
+                    if resized_processable:
+                        processable_batch.extend(resized_processable)
+                        logger.info(f"Successfully resized {item.item_key} to 50% for processing")
+                    else:
+                        logger.error(f"Item {item.item_key} still too long after resize, skipping")
+                        self.items_failed += 1
+
+                        # Send error result
+                        stage_result = StageResult(
+                            stage_name=stage_name,
+                            output_field=stage.output_field,
+                            outputs=[],
+                            error="Image too large even after resizing",
+                        )
+                        item.stage_results[stage_name] = stage_result
+
+                        self.result_queue.put(
+                            {
+                                "item": item,
+                                "outputs": {},
+                                "processing_time_ms": 0.0,
+                                "error": f"Failed stage {stage_name}: token limit exceeded",
+                            }
+                        )
 
-                    # Create template manager
+            # Process the validated batch
+            if processable_batch:
+                # Build requests for processable items
+                requests = []
+                for item in processable_batch:
+                    converted_img = ImageProcessor.prepare_for_inference(item)
                     template_manager = PromptTemplateManager(stage.prompts)
 
                     # Build context
                     context = item.metadata.copy()
-
-                    # Add previous stage results
                     for prev_stage_name, stage_result in item.stage_results.items():
                         for i, output in enumerate(stage_result.outputs):
                             context[f"{prev_stage_name}_output_{i}"] = output
@@ -769,14 +1009,7 @@ class CaptionWorker(BaseWorker):
                 outputs = llm.generate(requests, sampling_params)
 
                 # Process outputs
-                successful_items = []
-                failed_items = []
-
-                for idx, (original_idx, item, attempt_count) in enumerate(current_batch):
-                    if self.should_stop_processing.is_set():
-                        return results
-
-                    # Extract outputs
+                for idx, item in enumerate(processable_batch):
                     base_idx = idx * len(stage.prompts)
                     stage_outputs = []
 
@@ -788,40 +1021,18 @@ class CaptionWorker(BaseWorker):
                                 stage_outputs.append(cleaned_output)
 
                     if stage_outputs:
-                        # Success
                         stage_result = StageResult(
                             stage_name=stage_name,
                             output_field=stage.output_field,
                             outputs=stage_outputs,
                         )
                         item.stage_results[stage_name] = stage_result
-                        successful_items.append((original_idx, item))
                     else:
-                        # Failed - check retry
-                        if attempt_count + 1 < max_attempts:
-                            failed_items.append((original_idx, item, attempt_count + 1))
-                        else:
-                            logger.error(f"Stage {stage_name} failed for item {item.item_key}")
-                            self.items_failed += 1
-                            stage_result = StageResult(
-                                stage_name=stage_name,
-                                output_field=stage.output_field,
-                                outputs=[],
-                                error=f"Failed after {max_attempts} attempts",
-                            )
-                            item.stage_results[stage_name] = stage_result
-                            self.result_queue.put(
-                                {
-                                    "item": item,
-                                    "outputs": {},
-                                    "processing_time_ms": 0.0,
-                                    "error": f"Failed stage {stage_name} after {max_attempts} attempts",
-                                }
-                            )
-
-                # Update for next iteration
-                items_to_process = failed_items
-                batch = [item for _, item in successful_items]
+                        logger.error(f"No outputs for {item.item_key} in stage {stage_name}")
+                        self.items_failed += 1
+
+            # Update batch for next stage
+            batch = processable_batch
 
         # Convert to results
         for item in batch:

caption_flow/workers/data.py

@@ -1,20 +1,18 @@
 """DataWorker for retrieving data from various sources and forwarding to orchestrator or storage."""
 
 import asyncio
+import io
 import json
 import logging
-import io
-import time
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, Any, Optional, List, AsyncIterator
-from queue import Queue, Empty
-from threading import Thread, Event
+from queue import Empty, Queue
+from threading import Event
+from typing import Any, AsyncIterator, Dict, Optional
 
+import boto3
 import pandas as pd
 import pyarrow.parquet as pq
-from PIL import Image
-import boto3
 from botocore.config import Config
 
 from .base import BaseWorker
@@ -179,7 +177,7 @@ class DataWorker(BaseWorker):
                         try:
                             self.send_queue.put_nowait(batch)
                             batch = []
-                        except:
+                        except Exception:
                             # Queue full, wait
                             await asyncio.sleep(1)
 

{caption_flow-0.3.4.dist-info → caption_flow-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: caption-flow
-Version: 0.3.4
+Version: 0.4.1
 Summary: Self-contained distributed community captioning system
 Author-email: bghira <bghira@users.github.com>
 License: MIT
@@ -9,10 +9,9 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: <3.13,>=3.10
+Requires-Python: <3.13,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: websockets>=12.0
@@ -35,7 +34,9 @@ Requires-Dist: boto3<2.0.0,>=1.40.11
 Requires-Dist: torchdata<0.12.0,>=0.11.0
 Requires-Dist: textual<6.0.0,>=5.3.0
 Requires-Dist: urwid<4.0.0,>=3.0.2
-Requires-Dist: webshart<0.5.0,>=0.4.0
+Requires-Dist: webshart<0.5.0,>=0.4.3
+Requires-Dist: pylance<0.36.0,>=0.35.0
+Requires-Dist: duckdb<2.0.0,>=1.3.2
 Provides-Extra: dev
 Requires-Dist: pytest>=7.4.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
@@ -47,6 +48,10 @@ Dynamic: license-file
 
 # CaptionFlow
 
+<!-- [![Tests](https://github.com/bghira/CaptionFlow/workflows/tests/badge.svg)](https://github.com/bghira/CaptionFlow/actions/workflows/tests.yml) -->
+[![codecov](https://codecov.io/github/bghira/CaptionFlow/graph/badge.svg?token=PRAQPNGYAS)](https://codecov.io/github/bghira/CaptionFlow)
+[![PyPI version](https://badge.fury.io/py/caption-flow.svg)](https://badge.fury.io/py/caption-flow)
+
 scalable, fault-tolerant **vLLM-powered image captioning**.
 
 a fast websocket-based orchestrator paired with lightweight gpu workers achieves exceptional performance for batched requests through vLLM.

caption_flow-0.4.1.dist-info/RECORD

@@ -0,0 +1,33 @@
+caption_flow/__init__.py,sha256=AanaoBXNzR2j3ow-uWQQXmYpv6sUXLfLrqACm55_BMY,303
+caption_flow/cli.py,sha256=q3M6ekz70huVGD7NBqsO5xZUqMYBhLqe0ZGo85Vb69g,56072
+caption_flow/models.py,sha256=6-IJj_B3HAarucoLo8_PncJRnxofHuLFCsyRnmUXgRk,7063
+caption_flow/monitor.py,sha256=j5RExadSLOUujVZQMe7btMeKNlq-WbZ9bYqfikgYJ8Q,7972
+caption_flow/orchestrator.py,sha256=MWQKaAclI9rMjn7mWdvoSzl9y4b7bU_24aVr8I1YGhE,39645
+caption_flow/viewer.py,sha256=40w2Zj7GaXbK-dgqvYYdFrMzSDE_ZPWNZc6kS0OrymQ,20281
+caption_flow/processors/__init__.py,sha256=l1udEZLxAmqwFYS4-3GsRVcPT6WxnDOIk0s0UqsZsJM,423
+caption_flow/processors/base.py,sha256=Zx6kRZSqG969x8kYJ5VY2Mo5mLeWEgBCEpo8D4GjsBM,6935
+caption_flow/processors/huggingface.py,sha256=i-DZRt5nTnPN8180Yf8FKBiYPUPmxfKMEZ68CUZECWk,61603
+caption_flow/processors/local_filesystem.py,sha256=auAWxnqplEH4YJ1DWZCaFmAd03iyhNLudgt71N8O7NE,27827
+caption_flow/processors/webdataset.py,sha256=66y_7KaJBBntJqBHYKLzCXkBi9ly-TfYYaTCp_7pqTo,34206
+caption_flow/storage/__init__.py,sha256=IVnzcSCPpPuyp-QLlgJirRZ9Sb3tR0F4sfuF5u2cNMk,36
+caption_flow/storage/exporter.py,sha256=6atbxWgxSu_5qg9l8amwgkXRL1SKTZQb2yryu62yPc8,22371
+caption_flow/storage/manager.py,sha256=2jkyNl-2_B2Z7NfjCBua-Jgo7Km_JmJqMKrYsYj5uF4,41416
+caption_flow/utils/__init__.py,sha256=ULJImkcFPc8QH2Zz6TW7AeVXMFdRpvfni2MgEo_PRyY,120
+caption_flow/utils/auth.py,sha256=6HRNnWfX1j1Jh55M23crfSA1olkFGg-9kZ5Booy5wCM,2253
+caption_flow/utils/caption_utils.py,sha256=7k6GnElIAqyyzDHQd3JC3Ffr7r57sFWqS3ET7itzdoM,5309
+caption_flow/utils/certificates.py,sha256=NiHSeeZYKrf5BpAkwg5qOe-1C7-z42jZO3pjQo0N3I8,4889
+caption_flow/utils/checkpoint_tracker.py,sha256=LoCGjb30QOcMESHLF5hKVCd8X8_gWACyyq9EKLTXIn4,4613
+caption_flow/utils/chunk_tracker.py,sha256=And1krrTvpfiwG7xRxh9n6xy-_W8MSWSkcGmFSDFnB8,25460
+caption_flow/utils/image_processor.py,sha256=_dmiKXcAKxjkQ6d9V5QgoZSf_dDOL52tFMOEXa3iA24,1581
+caption_flow/utils/json_utils.py,sha256=AaGcNTToUcVYCQj2TXs2D_hxc_LeEqFquiK4CquS0U8,5537
+caption_flow/utils/prompt_template.py,sha256=mq7FPnpjp8gVCMMh4NtRf0vL_B9LDMuBkbySvACRSZM,4401
+caption_flow/utils/vllm_config.py,sha256=xFOnmniQGkUGwfTabfW6R0V01TF-_rN1UYJy0HwOvUI,6026
+caption_flow/workers/base.py,sha256=Yh_PBsL3j1kXUuIOQHqIdR69Nepfq11je23i01iWSxw,7714
+caption_flow/workers/caption.py,sha256=qph-TVMUqObRQBgriXOJtCgkWOo3qBdTg883D1TuXlw,48994
+caption_flow/workers/data.py,sha256=iWnTM7UgpJeFzhSTly-gHzFu5sIYUGG-XO4yRNn_MQk,14775
+caption_flow-0.4.1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+caption_flow-0.4.1.dist-info/METADATA,sha256=2mg45AYJVVZrgBzD611qFaWfNFId_3Xhl8xpwlFNrjg,10123
+caption_flow-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+caption_flow-0.4.1.dist-info/entry_points.txt,sha256=KnVlyrGKZj6p2zNyuEnCx4Y6jvJ4V-mcfN0lddPKTlQ,55
+caption_flow-0.4.1.dist-info/top_level.txt,sha256=_bXpKRutqded0FQ80dCChIz26ETV7tL4d4e2E_Y1FXs,13
+caption_flow-0.4.1.dist-info/RECORD,,