Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,55 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libavif.16.3.0.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libbrotlicommon.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libbrotlidec.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libfreetype.6.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libharfbuzz.0.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libjpeg.62.4.0.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/liblcms2.2.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/liblzma.5.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libopenjp2.2.5.3.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libpng16.16.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libtiff.6.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libwebp.7.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libwebpmux.3.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libxcb.1.1.0.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libz.1.3.1.zlib-ng.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/_imaging.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/PIL/_imagingft.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/charset_normalizer/md.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/charset_normalizer/md__mypyc.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/functorch/_C.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/hf_xet/hf_xet.abi3.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/.dylibs/libgcc_s.1.1.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/.dylibs/libgfortran.5.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/.dylibs/libquadmath.0.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/.dylibs/libscipy_openblas64_.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/_core/_multiarray_tests.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/_core/_multiarray_umath.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/_core/_simd.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/fft/_pocketfft_umath.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/linalg/_umath_linalg.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/random/_bounded_integers.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/random/_common.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/random/_generator.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/random/_mt19937.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/random/_pcg64.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/random/_philox.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/random/bit_generator.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/numpy/random/mtrand.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/pip/_vendor/distlib/t64-arm.exe filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/pip/_vendor/distlib/t64.exe filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/pip/_vendor/distlib/w64-arm.exe filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/pip/_vendor/distlib/w64.exe filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/regex/_regex.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/safetensors/_safetensors_rust.abi3.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/tokenizers/tokenizers.abi3.so filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/torch/bin/protoc filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/torch/bin/protoc-3.13.0.0 filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/torch/lib/libc10.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/torch/lib/libomp.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/torch/lib/libtorch_cpu.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/torch/lib/libtorch_python.dylib filter=lfs diff=lfs merge=lfs -text
+multi_model_env/lib/python3.13/site-packages/yaml/_yaml.cpython-313-darwin.so filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kunal Dhanda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

MANIFEST.in

@@ -0,0 +1,9 @@
+include README.md
+include MULTI_MODEL_README.md
+include requirements.txt
+include multi_model_requirements.txt
+include LICENSE
+include *.json
+include *.py
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co] 

MULTI_MODEL_README.md

@@ -0,0 +1,339 @@
+# Multi-Model Orchestrator: Parent-Child LLM System
+
+A sophisticated multi-model orchestration system that manages parent-child LLM relationships, specifically integrating the [CLIP-GPT2 Image Captioner](https://huggingface.co/kunaliitkgp09/clip-gpt2-image-captioner) and [Flickr30k Text-to-Image](https://huggingface.co/kunaliitkgp09/flickr30k-text-to-image) models.
+
+## 🚀 Features
+
+### **Parent Orchestrator**
+- **Intelligent Task Routing**: Automatically routes tasks to appropriate child models
+- **Model Management**: Handles loading, caching, and lifecycle of child models
+- **Error Handling**: Robust error handling and recovery mechanisms
+- **Task History**: Comprehensive logging and monitoring of all operations
+- **Async Support**: Both synchronous and asynchronous processing modes
+
+### **Child Models**
+- **CLIP-GPT2 Image Captioner**: Converts images to descriptive text captions
+- **Flickr30k Text-to-Image**: Generates images from text descriptions
+- **Extensible Architecture**: Easy to add new child models
+
+### **Advanced Capabilities**
+- **Multimodal Processing**: Combines multiple child models for complex tasks
+- **Batch Processing**: Handle multiple tasks efficiently
+- **Performance Monitoring**: Track processing times and success rates
+- **Memory Management**: Efficient GPU/CPU memory usage
+
+## 📁 Project Structure
+
+```
+├── multi_model_orchestrator.py    # Advanced orchestrator with full features
+├── simple_orchestrator.py         # Simplified interface matching original code
+├── multi_model_example.py         # Comprehensive examples and demonstrations
+├── multi_model_requirements.txt   # Dependencies for multi-model system
+└── MULTI_MODEL_README.md          # This file
+```
+
+## 🛠️ Installation
+
+1. **Install dependencies:**
+```bash
+pip install -r multi_model_requirements.txt
+```
+
+2. **Verify installation:**
+```python
+import torch
+from transformers import CLIPProcessor
+from diffusers import StableDiffusionPipeline
+print("All dependencies installed successfully!")
+```
+
+## 🎯 Quick Start
+
+### **Basic Usage (Matching Original Code)**
+
+```python
+from simple_orchestrator import SimpleMultiModelOrchestrator
+
+# Initialize orchestrator
+orchestrator = SimpleMultiModelOrchestrator()
+orchestrator.initialize_models()
+
+# Generate caption from image
+caption = orchestrator.generate_caption("sample_image.jpg")
+print(f"Caption: {caption}")
+
+# Generate image from text
+image_path = orchestrator.generate_image("A beautiful sunset over mountains")
+print(f"Generated image: {image_path}")
+
+# Route tasks
+caption = orchestrator.route_task("caption", "sample_image.jpg")
+image_path = orchestrator.route_task("generate_image", "A cat on a windowsill")
+```
+
+### **Advanced Usage**
+
+```python
+from multi_model_orchestrator import MultiModelOrchestrator
+import asyncio
+
+async def main():
+    # Initialize advanced orchestrator
+    orchestrator = MultiModelOrchestrator()
+    await orchestrator.initialize()
+    
+    # Multimodal processing
+    results = await orchestrator.process_multimodal(
+        image_path="sample_image.jpg",
+        text_prompt="A serene landscape with mountains"
+    )
+    
+    print("Results:", results)
+
+asyncio.run(main())
+```
+
+## 🔧 Model Integration
+
+### **Child Model 1: CLIP-GPT2 Image Captioner**
+- **Model**: `kunaliitkgp09/clip-gpt2-image-captioner`
+- **Task**: Image-to-text captioning
+- **Input**: Image file path
+- **Output**: Descriptive text caption
+- **Performance**: ~40% accuracy on test samples
+
+### **Child Model 2: Flickr30k Text-to-Image**
+- **Model**: `kunaliitkgp09/flickr30k-text-to-image`
+- **Task**: Text-to-image generation
+- **Input**: Text prompt
+- **Output**: Generated image file
+- **Performance**: Fine-tuned on Flickr30k dataset
+
+## 📊 Usage Examples
+
+### **1. Image Captioning**
+```python
+# Generate caption from image
+caption = orchestrator.generate_caption("path/to/image.jpg")
+print(f"Generated Caption: {caption}")
+```
+
+### **2. Text-to-Image Generation**
+```python
+# Generate image from text
+image_path = orchestrator.generate_image("A majestic eagle soaring over mountains")
+print(f"Generated Image: {image_path}")
+```
+
+### **3. Multimodal Processing**
+```python
+# Process both image and text together
+results = orchestrator.process_multimodal_task(
+    image_path="sample_image.jpg",
+    text_prompt="A serene landscape with mountains"
+)
+
+print("Caption:", results["caption"])
+print("Generated Image:", results["generated_image"])
+print("Analysis:", results["analysis_prompt"])
+```
+
+### **4. Async Processing**
+```python
+# Async version for better performance
+async def async_example():
+    results = await orchestrator.process_multimodal_async(
+        image_path="sample_image.jpg",
+        text_prompt="A futuristic cityscape"
+    )
+    return results
+```
+
+### **5. Batch Processing**
+```python
+# Process multiple tasks
+image_tasks = [
+    "A beautiful sunset",
+    "A cozy coffee shop",
+    "A vibrant garden"
+]
+
+for prompt in image_tasks:
+    image_path = orchestrator.generate_image(prompt)
+    print(f"Generated: {image_path}")
+```
+
+## 🔍 Task History and Monitoring
+
+```python
+# Get orchestrator status
+status = orchestrator.get_status()
+print(f"Status: {status}")
+
+# Get task history
+history = orchestrator.get_task_history()
+for task in history:
+    print(f"Task: {task['task_type']}, Time: {task['processing_time']:.2f}s")
+
+# Save task history
+orchestrator.save_task_history("my_tasks.json")
+```
+
+## ⚙️ Configuration Options
+
+### **Model Configuration**
+```python
+# Custom model parameters
+orchestrator = SimpleMultiModelOrchestrator(device="cuda")  # or "cpu"
+
+# Custom generation parameters
+image_path = orchestrator.generate_image(
+    "A beautiful landscape",
+    output_path="custom_output.png"
+)
+```
+
+### **Async Configuration**
+```python
+# Async orchestrator with concurrent processing
+async_orchestrator = AsyncMultiModelOrchestrator()
+
+# Process tasks concurrently
+results = await async_orchestrator.process_multimodal_async(
+    image_path="image.jpg",
+    text_prompt="prompt"
+)
+```
+
+## 🎯 Use Cases
+
+### **1. Content Creation**
+- Generate captions for social media images
+- Create images from text descriptions
+- Multimodal content analysis
+
+### **2. Research and Development**
+- Model performance comparison
+- Multimodal AI research
+- Prototype development
+
+### **3. Production Systems**
+- Automated content generation
+- Image analysis pipelines
+- Text-to-image applications
+
+### **4. Educational Applications**
+- AI model demonstration
+- Multimodal learning systems
+- Research toolkits
+
+## 🔧 Advanced Features
+
+### **Error Handling**
+```python
+try:
+    caption = orchestrator.generate_caption("image.jpg")
+except Exception as e:
+    print(f"Error: {e}")
+    # Handle error gracefully
+```
+
+### **Performance Optimization**
+```python
+# Use async for better performance
+async def optimized_processing():
+    tasks = [
+        orchestrator.generate_caption_async("image1.jpg"),
+        orchestrator.generate_caption_async("image2.jpg"),
+        orchestrator.generate_image_async("prompt1"),
+        orchestrator.generate_image_async("prompt2")
+    ]
+    
+    results = await asyncio.gather(*tasks)
+    return results
+```
+
+### **Custom Model Integration**
+```python
+# Add new child models
+class CustomChildModel:
+    def __init__(self, model_name):
+        self.model = load_model(model_name)
+    
+    def process(self, input_data):
+        # Custom processing logic
+        return result
+
+# Integrate with orchestrator
+orchestrator.add_child_model("custom_model", CustomChildModel("model_name"))
+```
+
+## 📈 Performance Metrics
+
+The orchestrator tracks various performance metrics:
+
+- **Processing Time**: Time taken for each task
+- **Success Rate**: Percentage of successful operations
+- **Memory Usage**: GPU/CPU memory consumption
+- **Model Load Times**: Time to initialize each child model
+- **Task Throughput**: Number of tasks processed per second
+
+## 🚨 Important Notes
+
+### **System Requirements**
+- **GPU**: Recommended for optimal performance (CUDA compatible)
+- **RAM**: 8GB+ for smooth operation
+- **Storage**: 5GB+ for model downloads and generated content
+- **Python**: 3.8+ required
+
+### **Model Downloads**
+- Models are downloaded automatically on first use
+- CLIP-GPT2: ~500MB
+- Stable Diffusion: ~4GB
+- Total initial download: ~5GB
+
+### **Memory Management**
+- Models are loaded into GPU memory when available
+- CPU fallback available for systems without GPU
+- Memory usage scales with batch size and model complexity
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit pull requests or open issues for:
+
+- New child model integrations
+- Performance improvements
+- Bug fixes
+- Documentation enhancements
+- Feature requests
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- **CLIP-GPT2 Model**: [kunaliitkgp09/clip-gpt2-image-captioner](https://huggingface.co/kunaliitkgp09/clip-gpt2-image-captioner)
+- **Stable Diffusion Model**: [kunaliitkgp09/flickr30k-text-to-image](https://huggingface.co/kunaliitkgp09/flickr30k-text-to-image)
+- **Hugging Face**: For providing the model hosting platform
+- **PyTorch**: For the deep learning framework
+- **Transformers**: For the model loading and processing utilities
+
+## 📚 References
+
+1. **CLIP**: "Learning Transferable Visual Representations" (Radford et al., 2021)
+2. **GPT-2**: "Language Models are Unsupervised Multitask Learners" (Radford et al., 2019)
+3. **Stable Diffusion**: "High-Resolution Image Synthesis with Latent Diffusion Models" (Rombach et al., 2022)
+4. **Flickr30k**: "From Image Descriptions to Visual Denotations" (Young et al., 2014)
+
+## 🔗 Links
+
+- **CLIP-GPT2 Model**: https://huggingface.co/kunaliitkgp09/clip-gpt2-image-captioner
+- **Flickr30k Text-to-Image**: https://huggingface.co/kunaliitkgp09/flickr30k-text-to-image
+- **Hugging Face Hub**: https://huggingface.co/
+- **PyTorch**: https://pytorch.org/
+- **Transformers**: https://huggingface.co/docs/transformers/
+
+---
+
+**Happy Orchestrating! 🚀** 

README.md

@@ -0,0 +1,139 @@
+---
+language:
+- en
+license: mit
+library_name: multi-model-orchestrator
+tags:
+- ai
+- machine-learning
+- multimodal
+- image-captioning
+- text-to-image
+- orchestration
+- transformers
+- pytorch
+---
+
+# Multi-Model Orchestrator
+
+A sophisticated multi-model orchestration system that manages parent-child LLM relationships, specifically integrating CLIP-GPT2 image captioner and Flickr30k text-to-image models.
+
+## 🚀 Features
+
+### **Parent Orchestrator**
+- **Intelligent Task Routing**: Automatically routes tasks to appropriate child models
+- **Model Management**: Handles loading, caching, and lifecycle of child models
+- **Error Handling**: Robust error handling and recovery mechanisms
+- **Task History**: Comprehensive logging and monitoring of all operations
+- **Async Support**: Both synchronous and asynchronous processing modes
+
+### **Child Models**
+- **CLIP-GPT2 Image Captioner**: Converts images to descriptive text captions
+- **Flickr30k Text-to-Image**: Generates images from text descriptions
+- **Extensible Architecture**: Easy to add new child models
+
+## 📦 Installation
+
+```bash
+pip install git+https://huggingface.co/kunaliitkgp09/multi-model-orchestrator
+```
+
+## 🎯 Quick Start
+
+```python
+from multi_model_orchestrator import SimpleMultiModelOrchestrator
+
+# Initialize orchestrator
+orchestrator = SimpleMultiModelOrchestrator()
+orchestrator.initialize_models()
+
+# Generate caption from image
+caption = orchestrator.generate_caption("sample_image.jpg")
+print(f"Caption: {caption}")
+
+# Generate image from text
+image_path = orchestrator.generate_image("A beautiful sunset over mountains")
+print(f"Generated image: {image_path}")
+```
+
+## 🔗 Model Integration
+
+### **Child Model 1: CLIP-GPT2 Image Captioner**
+- **Model**: `kunaliitkgp09/clip-gpt2-image-captioner`
+- **Task**: Image-to-text captioning
+- **Performance**: ~40% accuracy on test samples
+
+### **Child Model 2: Flickr30k Text-to-Image**
+- **Model**: `kunaliitkgp09/flickr30k-text-to-image`
+- **Task**: Text-to-image generation
+- **Performance**: Fine-tuned on Flickr30k dataset
+
+## 📊 Usage Examples
+
+### **Multimodal Processing**
+```python
+# Process both image and text together
+results = orchestrator.process_multimodal_task(
+    image_path="sample_image.jpg",
+    text_prompt="A serene landscape with mountains"
+)
+
+print("Caption:", results["caption"])
+print("Generated Image:", results["generated_image"])
+```
+
+### **Async Processing**
+```python
+from multi_model_orchestrator import AsyncMultiModelOrchestrator
+import asyncio
+
+async def async_example():
+    orchestrator = AsyncMultiModelOrchestrator()
+    orchestrator.initialize_models()
+    
+    results = await orchestrator.process_multimodal_async(
+        image_path="sample_image.jpg",
+        text_prompt="A futuristic cityscape"
+    )
+    return results
+
+asyncio.run(async_example())
+```
+
+## 🎯 Use Cases
+
+- **Content Creation**: Generate captions and images for social media
+- **Research and Development**: Model performance comparison and prototyping
+- **Production Systems**: Automated content generation pipelines
+- **Educational Applications**: AI model demonstration and learning
+
+## 📈 Performance Metrics
+
+- **Processing Time**: Optimized for real-time applications
+- **Memory Usage**: Efficient GPU/CPU memory management
+- **Success Rate**: Robust error handling and recovery
+- **Extensibility**: Easy integration of new child models
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit pull requests or open issues for:
+- New child model integrations
+- Performance improvements
+- Bug fixes
+- Documentation enhancements
+
+## 📄 License
+
+This project is licensed under the MIT License.
+
+## 🙏 Acknowledgments
+
+- **CLIP-GPT2 Model**: [kunaliitkgp09/clip-gpt2-image-captioner](https://huggingface.co/kunaliitkgp09/clip-gpt2-image-captioner)
+- **Stable Diffusion Model**: [kunaliitkgp09/flickr30k-text-to-image](https://huggingface.co/kunaliitkgp09/flickr30k-text-to-image)
+- **Hugging Face**: For providing the model hosting platform
+- **PyTorch**: For the deep learning framework
+- **Transformers**: For the model loading and processing utilities
+
+---
+
+**Happy Orchestrating! 🚀**

build/lib/multi_model_orchestrator/__init__.py

@@ -0,0 +1,27 @@
+"""
+Multi-Model Orchestrator: Parent-Child LLM System
+
+A sophisticated multi-model orchestration system that manages parent-child LLM relationships,
+specifically integrating CLIP-GPT2 image captioner and Flickr30k text-to-image models.
+
+Author: Kunal Dhanda
+Version: 1.0.0
+"""
+
+from .simple_orchestrator import SimpleMultiModelOrchestrator, AsyncMultiModelOrchestrator
+from .multi_model_orchestrator import MultiModelOrchestrator, ParentOrchestrator, ChildModel, ModelManager
+from .demo_orchestrator import DemoMultiModelOrchestrator
+
+__version__ = "1.0.0"
+__author__ = "Kunal Dhanda"
+__email__ = "kunaldhanda@example.com"
+
+__all__ = [
+    "SimpleMultiModelOrchestrator",
+    "AsyncMultiModelOrchestrator", 
+    "MultiModelOrchestrator",
+    "ParentOrchestrator",
+    "ChildModel",
+    "ModelManager",
+    "DemoMultiModelOrchestrator"
+] 

build/lib/multi_model_orchestrator/demo_orchestrator.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+Demo Multi-Model Orchestrator
+Shows the structure and functionality without downloading large models
+"""
+
+import time
+import json
+from typing import Dict, Any, Optional
+
+class DemoMultiModelOrchestrator:
+    """Demo orchestrator that simulates the multi-model system"""
+    
+    def __init__(self, device: str = "cpu"):
+        self.device = device
+        self.caption_model_name = "kunaliitkgp09/clip-gpt2-image-captioner"
+        self.text2img_model_name = "kunaliitkgp09/flickr30k-text-to-image"
+        
+        # Simulated model instances
+        self.caption_processor = None
+        self.caption_model = None
+        self.text2img_pipeline = None
+        self.tokenizer = None
+        
+        # Task history
+        self.task_history = []
+        
+    def initialize_models(self):
+        """Simulate model initialization"""
+        print("🔧 Initializing child models...")
+        
+        try:
+            # Simulate loading captioning model
+            print("📥 Loading CLIP-GPT2 captioning model...")
+            time.sleep(1)  # Simulate loading time
+            self.caption_processor = "CLIPProcessor"
+            self.caption_model = "CLIP-GPT2-Model"
+            self.tokenizer = "GPT2Tokenizer"
+            print("✅ Captioning model loaded")
+            
+            # Simulate loading text-to-image model
+            print("📥 Loading Stable Diffusion text-to-image model...")
+            time.sleep(1)  # Simulate loading time
+            self.text2img_pipeline = "StableDiffusionPipeline"
+            print("✅ Text-to-image model loaded")
+            
+            print("🎉 All models initialized successfully!")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error initializing models: {e}")
+            return False
+    
+    def generate_caption(self, image_path: str) -> str:
+        """Simulate image captioning"""
+        start_time = time.time()
+        
+        try:
+            print(f"🖼️  Processing image: {image_path}")
+            time.sleep(0.5)  # Simulate processing time
+            
+            # Simulate caption generation
+            sample_captions = [
+                "A beautiful landscape with mountains and trees",
+                "A person standing in front of a scenic view",
+                "A colorful sunset over the ocean",
+                "A cozy room with warm lighting",
+                "A busy street in a modern city"
+            ]
+            
+            import random
+            caption = random.choice(sample_captions)
+            
+            # Log task
+            self._log_task("caption", image_path, caption, time.time() - start_time)
+            
+            return caption
+            
+        except Exception as e:
+            print(f"❌ Error generating caption: {e}")
+            self._log_task("caption", image_path, None, time.time() - start_time, str(e))
+            raise
+    
+    def generate_image(self, text_prompt: str, output_path: Optional[str] = None) -> str:
+        """Simulate text-to-image generation"""
+        start_time = time.time()
+        
+        try:
+            print(f"🎨 Generating image from prompt: '{text_prompt}'")
+            time.sleep(1)  # Simulate generation time
+            
+            # Generate unique output path if not provided
+            if output_path is None:
+                timestamp = int(time.time())
+                output_path = f"generated_image_{timestamp}.png"
+            
+            # Simulate image generation
+            print(f"💾 Saving generated image to: {output_path}")
+            
+            # Log task
+            self._log_task("generate_image", text_prompt, output_path, time.time() - start_time)
+            
+            return output_path
+            
+        except Exception as e:
+            print(f"❌ Error generating image: {e}")
+            self._log_task("generate_image", text_prompt, None, time.time() - start_time, str(e))
+            raise
+    
+    def route_task(self, task_type: str, input_data: str) -> str:
+        """Parent model decides which child to call"""
+        print(f"🎯 Parent orchestrator routing task: {task_type}")
+        
+        if task_type == "caption":
+            return self.generate_caption(input_data)
+        elif task_type == "generate_image":
+            return self.generate_image(input_data)
+        else:
+            raise ValueError("Invalid task type: choose 'caption' or 'generate_image'")
+    
+    def process_multimodal_task(self, image_path: str, text_prompt: str) -> Dict[str, str]:
+        """Process a multimodal task using both child models"""
+        print("🔄 Processing multimodal task...")
+        results = {}
+        
+        # Step 1: Generate caption from image
+        try:
+            print("📝 Step 1: Generating caption from image...")
+            caption = self.generate_caption(image_path)
+            results["caption"] = caption
+        except Exception as e:
+            results["caption"] = f"Error: {str(e)}"
+        
+        # Step 2: Generate image from text prompt
+        try:
+            print("🎨 Step 2: Generating image from text...")
+            generated_image_path = self.generate_image(text_prompt)
+            results["generated_image"] = generated_image_path
+        except Exception as e:
+            results["generated_image"] = f"Error: {str(e)}"
+        
+        # Step 3: Create analysis prompt
+        if results["caption"] and not results["caption"].startswith("Error"):
+            analysis_prompt = f"Analyze this image caption: {results['caption']}"
+            results["analysis_prompt"] = analysis_prompt
+        
+        return results
+    
+    def _log_task(self, task_type: str, input_data: str, output: Any, 
+                  processing_time: float, error: Optional[str] = None):
+        """Log task execution"""
+        self.task_history.append({
+            "task_type": task_type,
+            "input_data": str(input_data)[:100],  # Truncate for logging
+            "output": str(output)[:200] if output else None,
+            "processing_time": processing_time,
+            "timestamp": time.time(),
+            "error": error
+        })
+    
+    def get_task_history(self) -> list:
+        """Get task execution history"""
+        return self.task_history
+    
+    def save_task_history(self, filepath: str = "demo_task_history.json"):
+        """Save task history to file"""
+        with open(filepath, 'w') as f:
+            json.dump(self.task_history, f, indent=2)
+        print(f"📄 Task history saved to {filepath}")
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get orchestrator status"""
+        return {
+            "models_loaded": {
+                "caption_model": self.caption_model is not None,
+                "text2img_pipeline": self.text2img_pipeline is not None
+            },
+            "total_tasks": len(self.task_history),
+            "device": self.device,
+            "child_models": {
+                "clip_gpt2_captioner": "kunaliitkgp09/clip-gpt2-image-captioner",
+                "flickr30k_text2img": "kunaliitkgp09/flickr30k-text-to-image"
+            }
+        }
+
+def demo_basic_usage():
+    """Demo 1: Basic usage of the orchestrator"""
+    print("="*60)
+    print("DEMO 1: BASIC USAGE")
+    print("="*60)
+    
+    # Initialize orchestrator
+    orchestrator = DemoMultiModelOrchestrator()
+    
+    # Initialize models
+    print("🚀 Initializing orchestrator...")
+    if not orchestrator.initialize_models():
+        print("❌ Failed to initialize models. Exiting.")
+        return
+    
+    # Get status
+    status = orchestrator.get_status()
+    print(f"\n📊 Orchestrator Status:")
+    print(json.dumps(status, indent=2))
+    
+    # Example 1: Image captioning
+    print("\n" + "-"*40)
+    print("🖼️  IMAGE CAPTIONING")
+    print("-"*40)
+    try:
+        caption = orchestrator.generate_caption("sample_image.jpg")
+        print(f"📝 Generated Caption: {caption}")
+    except Exception as e:
+        print(f"❌ Caption generation failed: {e}")
+    
+    # Example 2: Text-to-image generation
+    print("\n" + "-"*40)
+    print("🎨 TEXT-TO-IMAGE GENERATION")
+    print("-"*40)
+    try:
+        image_path = orchestrator.generate_image("A beautiful sunset over mountains with a lake")
+        print(f"🖼️  Generated Image: {image_path}")
+    except Exception as e:
+        print(f"❌ Image generation failed: {e}")
+    
+    # Example 3: Task routing
+    print("\n" + "-"*40)
+    print("🎯 TASK ROUTING")
+    print("-"*40)
+    try:
+        # Route caption task
+        caption = orchestrator.route_task("caption", "sample_image.jpg")
+        print(f"📝 Routed Caption: {caption}")
+        
+        # Route image generation task
+        image_path = orchestrator.route_task("generate_image", "A cat sitting on a windowsill")
+        print(f"🖼️  Routed Image: {image_path}")
+    except Exception as e:
+        print(f"❌ Task routing failed: {e}")
+
+def demo_multimodal_processing():
+    """Demo 2: Multimodal processing"""
+    print("\n" + "="*60)
+    print("DEMO 2: MULTIMODAL PROCESSING")
+    print("="*60)
+    
+    orchestrator = DemoMultiModelOrchestrator()
+    
+    if not orchestrator.initialize_models():
+        print("❌ Failed to initialize models. Exiting.")
+        return
+    
+    # Process multimodal task
+    print("🔄 Processing multimodal task...")
+    try:
+        results = orchestrator.process_multimodal_task(
+            image_path="sample_image.jpg",
+            text_prompt="A serene landscape with mountains and a flowing river"
+        )
+        
+        print("\n📊 Multimodal Results:")
+        for key, value in results.items():
+            print(f"  {key}: {value}")
+            
+    except Exception as e:
+        print(f"❌ Multimodal processing failed: {e}")
+
+def demo_task_history():
+    """Demo 3: Task history and monitoring"""
+    print("\n" + "="*60)
+    print("DEMO 3: TASK HISTORY")
+    print("="*60)
+    
+    orchestrator = DemoMultiModelOrchestrator()
+    
+    if not orchestrator.initialize_models():
+        print("❌ Failed to initialize models. Exiting.")
+        return
+    
+    # Perform some tasks
+    print("🔄 Performing tasks to build history...")
+    
+    try:
+        # Task 1
+        caption1 = orchestrator.generate_caption("image1.jpg")
+        print(f"📝 Task 1 - Caption: {caption1}")
+        
+        # Task 2
+        image1 = orchestrator.generate_image("A peaceful forest scene")
+        print(f"🖼️  Task 2 - Image: {image1}")
+        
+        # Task 3
+        caption2 = orchestrator.generate_caption("image2.jpg")
+        print(f"📝 Task 3 - Caption: {caption2}")
+        
+    except Exception as e:
+        print(f"❌ Task execution failed: {e}")
+    
+    # Display task history
+    print("\n" + "-"*40)
+    print("📋 TASK HISTORY")
+    print("-"*40)
+    history = orchestrator.get_task_history()
+    
+    for i, task in enumerate(history):
+        print(f"\n📊 Task {i+1}:")
+        print(f"  Type: {task['task_type']}")
+        print(f"  Input: {task['input_data']}")
+        print(f"  Output: {task['output']}")
+        print(f"  Processing Time: {task['processing_time']:.2f}s")
+        print(f"  Success: {task.get('error') is None}")
+        if task.get('error'):
+            print(f"  Error: {task['error']}")
+    
+    # Save task history
+    orchestrator.save_task_history("demo_task_history.json")
+    print(f"\n💾 Task history saved to demo_task_history.json")
+
+def main():
+    """Run all demos"""
+    print("🎭 Multi-Model Orchestrator Demo")
+    print("This demo shows the structure and functionality of the orchestrator.")
+    print("Note: This is a simulation - actual models would be downloaded and used.")
+    
+    try:
+        # Run demos
+        demo_basic_usage()
+        demo_multimodal_processing()
+        demo_task_history()
+        
+        print("\n" + "="*60)
+        print("🎉 ALL DEMOS COMPLETED SUCCESSFULLY!")
+        print("="*60)
+        
+        print("\n📁 Generated files:")
+        print("  - demo_task_history.json (task history)")
+        
+        print("\n🔗 Real Model Links:")
+        print("  - CLIP-GPT2 Captioner: https://huggingface.co/kunaliitkgp09/clip-gpt2-image-captioner")
+        print("  - Flickr30k Text-to-Image: https://huggingface.co/kunaliitkgp09/flickr30k-text-to-image")
+        
+        print("\n🚀 Next steps:")
+        print("1. Install dependencies: pip install -r multi_model_requirements.txt")
+        print("2. Run with real models: python multi_model_example.py")
+        print("3. Integrate into your applications")
+        print("4. Add more child models to the system")
+        
+    except Exception as e:
+        print(f"\n❌ Error during execution: {e}")
+
+if __name__ == "__main__":
+    main() 

build/lib/multi_model_orchestrator/multi_model_orchestrator.py

@@ -0,0 +1,497 @@
+import torch
+import asyncio
+import logging
+import json
+import time
+from typing import Dict, List, Optional, Union, Any
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+import traceback
+
+from transformers import AutoProcessor, AutoModelForCausalLM, CLIPProcessor, GPT2Tokenizer
+from diffusers import StableDiffusionPipeline
+from PIL import Image
+import numpy as np
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TaskType(Enum):
+    """Enumeration of supported task types"""
+    IMAGE_TO_TEXT = "image_to_text"
+    TEXT_TO_IMAGE = "text_to_image"
+    IMAGE_ANALYSIS = "image_analysis"
+    TEXT_GENERATION = "text_generation"
+    MULTIMODAL_GENERATION = "multimodal_generation"
+
+@dataclass
+class ModelConfig:
+    """Configuration for child models"""
+    name: str
+    model_type: str
+    device: str = "cuda"
+    max_length: int = 50
+    temperature: float = 0.7
+    top_p: float = 0.9
+    batch_size: int = 1
+
+@dataclass
+class TaskResult:
+    """Result from a child model task"""
+    success: bool
+    output: Any
+    model_used: str
+    processing_time: float
+    error_message: Optional[str] = None
+    metadata: Optional[Dict] = None
+
+class ModelManager:
+    """Manages loading and caching of child models"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.device = device if torch.cuda.is_available() else "cpu"
+        self.models = {}
+        self.processors = {}
+        self.pipelines = {}
+        self.model_configs = {}
+        
+    def register_model(self, name: str, config: ModelConfig):
+        """Register a model configuration"""
+        self.model_configs[name] = config
+        
+    def load_model(self, name: str) -> bool:
+        """Load a specific model"""
+        if name not in self.model_configs:
+            logger.error(f"Model {name} not registered")
+            return False
+            
+        config = self.model_configs[name]
+        
+        try:
+            logger.info(f"Loading model: {name}")
+            start_time = time.time()
+            
+            if config.model_type == "caption":
+                # Load CLIP-GPT2 captioning model
+                self.processors[name] = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch16")
+                self.models[name] = AutoModelForCausalLM.from_pretrained(config.name).to(self.device)
+                
+            elif config.model_type == "text2img":
+                # Load Stable Diffusion text-to-image model
+                self.pipelines[name] = StableDiffusionPipeline.from_pretrained(
+                    config.name,
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                ).to(self.device)
+                
+            elif config.model_type == "llm":
+                # Load general language model
+                self.processors[name] = AutoProcessor.from_pretrained(config.name)
+                self.models[name] = AutoModelForCausalLM.from_pretrained(config.name).to(self.device)
+                
+            load_time = time.time() - start_time
+            logger.info(f"Model {name} loaded successfully in {load_time:.2f}s")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to load model {name}: {str(e)}")
+            return False
+    
+    def get_model(self, name: str):
+        """Get a loaded model"""
+        if name in self.models:
+            return self.models[name]
+        elif name in self.pipelines:
+            return self.pipelines[name]
+        else:
+            raise ValueError(f"Model {name} not loaded")
+    
+    def get_processor(self, name: str):
+        """Get a model processor"""
+        if name in self.processors:
+            return self.processors[name]
+        else:
+            raise ValueError(f"Processor for {name} not loaded")
+
+class ChildModel:
+    """Base class for child models"""
+    
+    def __init__(self, name: str, model_manager: ModelManager):
+        self.name = name
+        self.model_manager = model_manager
+        self.config = model_manager.model_configs[name]
+        
+    async def process(self, input_data: Any) -> TaskResult:
+        """Process input data and return result"""
+        start_time = time.time()
+        
+        try:
+            if self.config.model_type == "caption":
+                result = await self._process_caption(input_data)
+            elif self.config.model_type == "text2img":
+                result = await self._process_text2img(input_data)
+            elif self.config.model_type == "llm":
+                result = await self._process_llm(input_data)
+            else:
+                raise ValueError(f"Unknown model type: {self.config.model_type}")
+                
+            processing_time = time.time() - start_time
+            
+            return TaskResult(
+                success=True,
+                output=result,
+                model_used=self.name,
+                processing_time=processing_time,
+                metadata={"model_type": self.config.model_type}
+            )
+            
+        except Exception as e:
+            processing_time = time.time() - start_time
+            logger.error(f"Error in model {self.name}: {str(e)}")
+            
+            return TaskResult(
+                success=False,
+                output=None,
+                model_used=self.name,
+                processing_time=processing_time,
+                error_message=str(e)
+            )
+    
+    async def _process_caption(self, image_path: str) -> str:
+        """Process image captioning task"""
+        # Run in thread pool to avoid blocking
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self._caption_sync, image_path)
+    
+    def _caption_sync(self, image_path: str) -> str:
+        """Synchronous image captioning"""
+        image = Image.open(image_path).convert("RGB")
+        processor = self.model_manager.get_processor(self.name)
+        model = self.model_manager.get_model(self.name)
+        
+        inputs = processor(images=image, return_tensors="pt").to(self.device)
+        
+        with torch.no_grad():
+            output = model.generate(
+                **inputs,
+                max_length=self.config.max_length,
+                temperature=self.config.temperature,
+                top_p=self.config.top_p,
+                do_sample=True,
+                pad_token_id=processor.tokenizer.eos_token_id
+            )
+        
+        caption = processor.tokenizer.batch_decode(output, skip_special_tokens=True)[0]
+        return caption
+    
+    async def _process_text2img(self, prompt: str) -> str:
+        """Process text-to-image generation task"""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self._text2img_sync, prompt)
+    
+    def _text2img_sync(self, prompt: str) -> str:
+        """Synchronous text-to-image generation"""
+        pipeline = self.model_manager.get_model(self.name)
+        
+        # Generate unique output path
+        timestamp = int(time.time())
+        output_path = f"generated_image_{timestamp}.png"
+        
+        with torch.no_grad():
+            image = pipeline(
+                prompt,
+                num_inference_steps=20,
+                guidance_scale=7.5,
+                width=512,
+                height=512
+            ).images[0]
+        
+        image.save(output_path)
+        return output_path
+    
+    async def _process_llm(self, text: str) -> str:
+        """Process general language model task"""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self._llm_sync, text)
+    
+    def _llm_sync(self, text: str) -> str:
+        """Synchronous language model processing"""
+        processor = self.model_manager.get_processor(self.name)
+        model = self.model_manager.get_model(self.name)
+        
+        inputs = processor(text, return_tensors="pt").to(self.device)
+        
+        with torch.no_grad():
+            output = model.generate(
+                **inputs,
+                max_length=self.config.max_length,
+                temperature=self.config.temperature,
+                top_p=self.config.top_p,
+                do_sample=True,
+                pad_token_id=processor.tokenizer.eos_token_id
+            )
+        
+        result = processor.tokenizer.batch_decode(output, skip_special_tokens=True)[0]
+        return result
+
+class ParentOrchestrator:
+    """Parent model that orchestrates child models"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.device = device if torch.cuda.is_available() else "cpu"
+        self.model_manager = ModelManager(device)
+        self.child_models = {}
+        self.task_history = []
+        
+        # Register child models
+        self._register_child_models()
+        
+    def _register_child_models(self):
+        """Register all child models"""
+        # CLIP-GPT2 Image Captioner
+        self.model_manager.register_model(
+            "clip_gpt2_captioner",
+            ModelConfig(
+                name="kunaliitkgp09/clip-gpt2-image-captioner",
+                model_type="caption",
+                device=self.device,
+                max_length=50,
+                temperature=0.7
+            )
+        )
+        
+        # Flickr30k Text-to-Image
+        self.model_manager.register_model(
+            "flickr30k_text2img",
+            ModelConfig(
+                name="kunaliitkgp09/flickr30k-text-to-image",
+                model_type="text2img",
+                device=self.device,
+                temperature=0.8
+            )
+        )
+        
+        # Optional: Add a general LLM for text processing
+        self.model_manager.register_model(
+            "gpt2_text",
+            ModelConfig(
+                name="gpt2",
+                model_type="llm",
+                device=self.device,
+                max_length=100,
+                temperature=0.8
+            )
+        )
+    
+    async def initialize_models(self):
+        """Initialize all child models"""
+        logger.info("Initializing child models...")
+        
+        for model_name in self.model_manager.model_configs:
+            success = self.model_manager.load_model(model_name)
+            if success:
+                self.child_models[model_name] = ChildModel(model_name, self.model_manager)
+                logger.info(f"Child model {model_name} initialized successfully")
+            else:
+                logger.error(f"Failed to initialize child model {model_name}")
+    
+    async def route_task(self, task_type: TaskType, input_data: Any, 
+                        model_name: Optional[str] = None) -> TaskResult:
+        """Route task to appropriate child model"""
+        
+        # Determine which model to use
+        if model_name is None:
+            model_name = self._select_model_for_task(task_type)
+        
+        if model_name not in self.child_models:
+            return TaskResult(
+                success=False,
+                output=None,
+                model_used=model_name,
+                processing_time=0.0,
+                error_message=f"Model {model_name} not available"
+            )
+        
+        # Process task
+        child_model = self.child_models[model_name]
+        result = await child_model.process(input_data)
+        
+        # Log task
+        self.task_history.append({
+            "task_type": task_type.value,
+            "model_used": model_name,
+            "input_data": str(input_data)[:100],  # Truncate for logging
+            "success": result.success,
+            "processing_time": result.processing_time,
+            "timestamp": time.time()
+        })
+        
+        return result
+    
+    def _select_model_for_task(self, task_type: TaskType) -> str:
+        """Select appropriate model for task type"""
+        if task_type == TaskType.IMAGE_TO_TEXT:
+            return "clip_gpt2_captioner"
+        elif task_type == TaskType.TEXT_TO_IMAGE:
+            return "flickr30k_text2img"
+        elif task_type == TaskType.TEXT_GENERATION:
+            return "gpt2_text"
+        else:
+            raise ValueError(f"No model available for task type: {task_type}")
+    
+    async def process_multimodal_task(self, image_path: str, text_prompt: str) -> Dict[str, TaskResult]:
+        """Process a multimodal task using multiple child models"""
+        results = {}
+        
+        # Step 1: Generate caption from image
+        caption_result = await self.route_task(
+            TaskType.IMAGE_TO_TEXT, 
+            image_path, 
+            "clip_gpt2_captioner"
+        )
+        results["caption"] = caption_result
+        
+        # Step 2: Generate image from text prompt
+        image_result = await self.route_task(
+            TaskType.TEXT_TO_IMAGE, 
+            text_prompt, 
+            "flickr30k_text2img"
+        )
+        results["generated_image"] = image_result
+        
+        # Step 3: Generate text analysis using LLM
+        if caption_result.success:
+            analysis_prompt = f"Analyze this image caption: {caption_result.output}"
+            analysis_result = await self.route_task(
+                TaskType.TEXT_GENERATION, 
+                analysis_prompt, 
+                "gpt2_text"
+            )
+            results["analysis"] = analysis_result
+        
+        return results
+    
+    def get_task_history(self) -> List[Dict]:
+        """Get task execution history"""
+        return self.task_history
+    
+    def get_model_status(self) -> Dict[str, bool]:
+        """Get status of all child models"""
+        return {
+            name: name in self.child_models 
+            for name in self.model_manager.model_configs
+        }
+    
+    def save_task_history(self, filepath: str):
+        """Save task history to file"""
+        with open(filepath, 'w') as f:
+            json.dump(self.task_history, f, indent=2)
+        logger.info(f"Task history saved to {filepath}")
+
+class MultiModelOrchestrator:
+    """Main orchestrator class with simplified interface"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.parent = ParentOrchestrator(device)
+        self.initialized = False
+    
+    async def initialize(self):
+        """Initialize the orchestrator"""
+        await self.parent.initialize_models()
+        self.initialized = True
+        logger.info("Multi-model orchestrator initialized successfully")
+    
+    async def generate_caption(self, image_path: str) -> str:
+        """Generate caption from image"""
+        if not self.initialized:
+            await self.initialize()
+        
+        result = await self.parent.route_task(TaskType.IMAGE_TO_TEXT, image_path)
+        
+        if result.success:
+            return result.output
+        else:
+            raise RuntimeError(f"Caption generation failed: {result.error_message}")
+    
+    async def generate_image(self, text_prompt: str) -> str:
+        """Generate image from text"""
+        if not self.initialized:
+            await self.initialize()
+        
+        result = await self.parent.route_task(TaskType.TEXT_TO_IMAGE, text_prompt)
+        
+        if result.success:
+            return result.output
+        else:
+            raise RuntimeError(f"Image generation failed: {result.error_message}")
+    
+    async def process_multimodal(self, image_path: str, text_prompt: str) -> Dict[str, Any]:
+        """Process multimodal task"""
+        if not self.initialized:
+            await self.initialize()
+        
+        results = await self.parent.process_multimodal_task(image_path, text_prompt)
+        
+        # Extract outputs
+        output = {}
+        for key, result in results.items():
+            if result.success:
+                output[key] = result.output
+            else:
+                output[key] = f"Error: {result.error_message}"
+        
+        return output
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get orchestrator status"""
+        return {
+            "initialized": self.initialized,
+            "model_status": self.parent.get_model_status(),
+            "total_tasks": len(self.parent.get_task_history())
+        }
+
+# Usage examples
+async def main():
+    """Example usage of the multi-model orchestrator"""
+    
+    # Initialize orchestrator
+    orchestrator = MultiModelOrchestrator()
+    await orchestrator.initialize()
+    
+    print("Multi-Model Orchestrator Status:")
+    print(json.dumps(orchestrator.get_status(), indent=2))
+    
+    # Example 1: Image captioning
+    try:
+        # Note: Replace with actual image path
+        caption = await orchestrator.generate_caption("sample_image.jpg")
+        print(f"\nGenerated Caption: {caption}")
+    except Exception as e:
+        print(f"Caption generation error: {e}")
+    
+    # Example 2: Text-to-image generation
+    try:
+        image_path = await orchestrator.generate_image("A beautiful sunset over mountains")
+        print(f"\nGenerated Image saved at: {image_path}")
+    except Exception as e:
+        print(f"Image generation error: {e}")
+    
+    # Example 3: Multimodal processing
+    try:
+        multimodal_result = await orchestrator.process_multimodal(
+            "sample_image.jpg", 
+            "A serene landscape with mountains"
+        )
+        print(f"\nMultimodal Results:")
+        for key, value in multimodal_result.items():
+            print(f"  {key}: {value}")
+    except Exception as e:
+        print(f"Multimodal processing error: {e}")
+    
+    # Save task history
+    orchestrator.parent.save_task_history("task_history.json")
+
+if __name__ == "__main__":
+    # Run the example
+    asyncio.run(main()) 

build/lib/multi_model_orchestrator/simple_orchestrator.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Simplified Multi-Model Orchestrator
+Based on the original code structure with enhanced functionality
+"""
+
+import asyncio
+import torch
+from transformers import CLIPProcessor, GPT2Tokenizer
+from diffusers import StableDiffusionPipeline
+from PIL import Image
+import time
+import json
+from typing import Dict, Any, Optional
+
+class SimpleMultiModelOrchestrator:
+    """Simplified orchestrator matching the original code structure"""
+    
+    def __init__(self, device: str = "cuda"):
+        self.device = device if torch.cuda.is_available() else "cpu"
+        self.caption_model_name = "kunaliitkgp09/clip-gpt2-image-captioner"
+        self.text2img_model_name = "kunaliitkgp09/flickr30k-text-to-image"
+        
+        # Model instances
+        self.caption_processor = None
+        self.caption_model = None
+        self.text2img_pipeline = None
+        self.tokenizer = None
+        
+        # Task history
+        self.task_history = []
+        
+    def initialize_models(self):
+        """Initialize all child models"""
+        print("Initializing child models...")
+        
+        try:
+            # Load captioning model
+            print("Loading CLIP-GPT2 captioning model...")
+            self.caption_processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch16")
+            self.caption_model = torch.hub.load('huggingface/pytorch-transformers', 'model', 
+                                              self.caption_model_name).to(self.device)
+            self.tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+            print("✓ Captioning model loaded")
+            
+            # Load text-to-image model
+            print("Loading Stable Diffusion text-to-image model...")
+            self.text2img_pipeline = StableDiffusionPipeline.from_pretrained(
+                self.text2img_model_name,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+            ).to(self.device)
+            print("✓ Text-to-image model loaded")
+            
+            print("All models initialized successfully!")
+            return True
+            
+        except Exception as e:
+            print(f"Error initializing models: {e}")
+            return False
+    
+    def generate_caption(self, image_path: str) -> str:
+        """Child Model 1 - Image Captioning"""
+        start_time = time.time()
+        
+        try:
+            image = Image.open(image_path).convert("RGB")
+            
+            # Process image with CLIP
+            inputs = self.caption_processor(images=image, return_tensors="pt").to(self.device)
+            
+            # Generate caption
+            with torch.no_grad():
+                output = self.caption_model.generate(
+                    **inputs,
+                    max_length=50,
+                    temperature=0.7,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            caption = self.tokenizer.batch_decode(output, skip_special_tokens=True)[0]
+            
+            # Log task
+            self._log_task("caption", image_path, caption, time.time() - start_time)
+            
+            return caption
+            
+        except Exception as e:
+            print(f"Error generating caption: {e}")
+            self._log_task("caption", image_path, None, time.time() - start_time, str(e))
+            raise
+    
+    def generate_image(self, text_prompt: str, output_path: Optional[str] = None) -> str:
+        """Child Model 2 - Text-to-Image"""
+        start_time = time.time()
+        
+        try:
+            # Generate unique output path if not provided
+            if output_path is None:
+                timestamp = int(time.time())
+                output_path = f"generated_image_{timestamp}.png"
+            
+            # Generate image
+            with torch.no_grad():
+                image = self.text2img_pipeline(
+                    text_prompt,
+                    num_inference_steps=20,
+                    guidance_scale=7.5,
+                    width=512,
+                    height=512
+                ).images[0]
+            
+            # Save image
+            image.save(output_path)
+            
+            # Log task
+            self._log_task("generate_image", text_prompt, output_path, time.time() - start_time)
+            
+            return output_path
+            
+        except Exception as e:
+            print(f"Error generating image: {e}")
+            self._log_task("generate_image", text_prompt, None, time.time() - start_time, str(e))
+            raise
+    
+    def route_task(self, task_type: str, input_data: str) -> str:
+        """Parent model decides which child to call"""
+        if task_type == "caption":
+            return self.generate_caption(input_data)
+        elif task_type == "generate_image":
+            return self.generate_image(input_data)
+        else:
+            raise ValueError("Invalid task type: choose 'caption' or 'generate_image'")
+    
+    def process_multimodal_task(self, image_path: str, text_prompt: str) -> Dict[str, str]:
+        """Process a multimodal task using both child models"""
+        results = {}
+        
+        # Step 1: Generate caption from image
+        try:
+            caption = self.generate_caption(image_path)
+            results["caption"] = caption
+        except Exception as e:
+            results["caption"] = f"Error: {str(e)}"
+        
+        # Step 2: Generate image from text prompt
+        try:
+            generated_image_path = self.generate_image(text_prompt)
+            results["generated_image"] = generated_image_path
+        except Exception as e:
+            results["generated_image"] = f"Error: {str(e)}"
+        
+        # Step 3: Create analysis prompt
+        if results["caption"] and not results["caption"].startswith("Error"):
+            analysis_prompt = f"Analyze this image caption: {results['caption']}"
+            results["analysis_prompt"] = analysis_prompt
+        
+        return results
+    
+    def _log_task(self, task_type: str, input_data: str, output: Any, 
+                  processing_time: float, error: Optional[str] = None):
+        """Log task execution"""
+        self.task_history.append({
+            "task_type": task_type,
+            "input_data": str(input_data)[:100],  # Truncate for logging
+            "output": str(output)[:200] if output else None,
+            "processing_time": processing_time,
+            "timestamp": time.time(),
+            "error": error
+        })
+    
+    def get_task_history(self) -> list:
+        """Get task execution history"""
+        return self.task_history
+    
+    def save_task_history(self, filepath: str = "task_history.json"):
+        """Save task history to file"""
+        with open(filepath, 'w') as f:
+            json.dump(self.task_history, f, indent=2)
+        print(f"Task history saved to {filepath}")
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get orchestrator status"""
+        return {
+            "models_loaded": {
+                "caption_model": self.caption_model is not None,
+                "text2img_pipeline": self.text2img_pipeline is not None
+            },
+            "total_tasks": len(self.task_history),
+            "device": self.device
+        }
+
+# Async version for better performance
+class AsyncMultiModelOrchestrator(SimpleMultiModelOrchestrator):
+    """Async version of the orchestrator"""
+    
+    async def generate_caption_async(self, image_path: str) -> str:
+        """Async image captioning"""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self.generate_caption, image_path)
+    
+    async def generate_image_async(self, text_prompt: str, output_path: Optional[str] = None) -> str:
+        """Async text-to-image generation"""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self.generate_image, text_prompt, output_path)
+    
+    async def process_multimodal_async(self, image_path: str, text_prompt: str) -> Dict[str, str]:
+        """Async multimodal processing"""
+        # Run both tasks concurrently
+        caption_task = self.generate_caption_async(image_path)
+        image_task = self.generate_image_async(text_prompt)
+        
+        results = {}
+        
+        try:
+            # Wait for both tasks to complete
+            caption, generated_image_path = await asyncio.gather(
+                caption_task, image_task, return_exceptions=True
+            )
+            
+            # Handle results
+            if isinstance(caption, Exception):
+                results["caption"] = f"Error: {str(caption)}"
+            else:
+                results["caption"] = caption
+            
+            if isinstance(generated_image_path, Exception):
+                results["generated_image"] = f"Error: {str(generated_image_path)}"
+            else:
+                results["generated_image"] = generated_image_path
+            
+            # Create analysis prompt
+            if results["caption"] and not results["caption"].startswith("Error"):
+                analysis_prompt = f"Analyze this image caption: {results['caption']}"
+                results["analysis_prompt"] = analysis_prompt
+            
+        except Exception as e:
+            results["error"] = f"Multimodal processing failed: {str(e)}"
+        
+        return results
+
+# Usage examples
+def main():
+    """Example usage of the multi-model orchestrator"""
+    
+    # Initialize orchestrator
+    orchestrator = SimpleMultiModelOrchestrator()
+    
+    # Initialize models
+    if not orchestrator.initialize_models():
+        print("Failed to initialize models. Exiting.")
+        return
+    
+    print("\nMulti-Model Orchestrator Status:")
+    print(json.dumps(orchestrator.get_status(), indent=2))
+    
+    # Example 1: Image captioning
+    try:
+        # Note: Replace with actual image path
+        caption = orchestrator.route_task("caption", "sample_image.jpg")
+        print(f"\nGenerated Caption: {caption}")
+    except Exception as e:
+        print(f"Caption generation error: {e}")
+    
+    # Example 2: Text-to-image generation
+    try:
+        image_path = orchestrator.route_task("generate_image", "A beautiful sunset over mountains")
+        print(f"\nGenerated Image saved at: {image_path}")
+    except Exception as e:
+        print(f"Image generation error: {e}")
+    
+    # Example 3: Multimodal processing
+    try:
+        multimodal_result = orchestrator.process_multimodal_task(
+            "sample_image.jpg", 
+            "A serene landscape with mountains"
+        )
+        print(f"\nMultimodal Results:")
+        for key, value in multimodal_result.items():
+            print(f"  {key}: {value}")
+    except Exception as e:
+        print(f"Multimodal processing error: {e}")
+    
+    # Save task history
+    orchestrator.save_task_history()
+
+async def async_main():
+    """Async example usage"""
+    
+    # Initialize async orchestrator
+    orchestrator = AsyncMultiModelOrchestrator()
+    
+    # Initialize models
+    if not orchestrator.initialize_models():
+        print("Failed to initialize models. Exiting.")
+        return
+    
+    print("\nAsync Multi-Model Orchestrator Status:")
+    print(json.dumps(orchestrator.get_status(), indent=2))
+    
+    # Example: Concurrent multimodal processing
+    try:
+        multimodal_result = await orchestrator.process_multimodal_async(
+            "sample_image.jpg", 
+            "A beautiful sunset over mountains"
+        )
+        print(f"\nAsync Multimodal Results:")
+        for key, value in multimodal_result.items():
+            print(f"  {key}: {value}")
+    except Exception as e:
+        print(f"Async multimodal processing error: {e}")
+    
+    # Save task history
+    orchestrator.save_task_history("async_task_history.json")
+
+if __name__ == "__main__":
+    print("Running synchronous example...")
+    main()
+    
+    print("\n" + "="*50)
+    print("Running async example...")
+    asyncio.run(async_main()) 

dist/multi_model_orchestrator-1.0.0.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49e6ac00733a0b80bddbc4b49c8785b73b7d9741094e5ec11e56bb8ffd014015
+size 20248

main.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Main entry point for Multi-Model Orchestrator
+"""
+
+import sys
+import argparse
+from multi_model_orchestrator import DemoMultiModelOrchestrator, SimpleMultiModelOrchestrator
+
+def main():
+    parser = argparse.ArgumentParser(description="Multi-Model Orchestrator")
+    parser.add_argument("--demo", action="store_true", help="Run demo mode")
+    parser.add_argument("--real", action="store_true", help="Run with real models")
+    parser.add_argument("--caption", type=str, help="Generate caption for image")
+    parser.add_argument("--generate-image", type=str, help="Generate image from text")
+    parser.add_argument("--multimodal", nargs=2, metavar=("IMAGE", "TEXT"), 
+                       help="Process multimodal task (image_path text_prompt)")
+    
+    args = parser.parse_args()
+    
+    if args.demo:
+        # Run demo
+        from multi_model_orchestrator.demo_orchestrator import main as demo_main
+        demo_main()
+    elif args.real:
+        # Run with real models
+        print("Real model mode - requires model downloads")
+        print("Use: python -m multi_model_orchestrator.multi_model_example")
+    elif args.caption:
+        # Generate caption
+        orchestrator = DemoMultiModelOrchestrator()
+        orchestrator.initialize_models()
+        caption = orchestrator.generate_caption(args.caption)
+        print(f"Caption: {caption}")
+    elif args.generate_image:
+        # Generate image
+        orchestrator = DemoMultiModelOrchestrator()
+        orchestrator.initialize_models()
+        image_path = orchestrator.generate_image(args.generate_image)
+        print(f"Generated image: {image_path}")
+    elif args.multimodal:
+        # Multimodal processing
+        image_path, text_prompt = args.multimodal
+        orchestrator = DemoMultiModelOrchestrator()
+        orchestrator.initialize_models()
+        results = orchestrator.process_multimodal_task(image_path, text_prompt)
+        print("Results:")
+        for key, value in results.items():
+            print(f"  {key}: {value}")
+    else:
+        # Default: run demo
+        from multi_model_orchestrator.demo_orchestrator import main as demo_main
+        demo_main()
+
+if __name__ == "__main__":
+    main() 

multi_model_env/.gitignore

@@ -0,0 +1,2 @@
+# Created by venv; see https://docs.python.org/3/library/venv.html
+*

multi_model_env/bin/Activate.ps1

@@ -0,0 +1,248 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+$env:VIRTUAL_ENV_PROMPT = $Prompt
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

multi_model_env/bin/activate

@@ -0,0 +1,76 @@
+# This file must be used with "source bin/activate" *from bash*
+# You cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # Call hash to forget past locations. Without forgetting
+    # past locations the $PATH changes we made may not be respected.
+    # See "man bash" for more details. hash is usually a builtin of your shell
+    hash -r 2> /dev/null
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+# on Windows, a path can contain colons and backslashes and has to be converted:
+case "$(uname)" in
+    CYGWIN*|MSYS*|MINGW*)
+        # transform D:\path\to\venv to /d/path/to/venv on MSYS and MINGW
+        # and to /cygdrive/d/path/to/venv on Cygwin
+        VIRTUAL_ENV=$(cygpath /Users/kunaldhanda/DeepSeek/multi_model_env)
+        export VIRTUAL_ENV
+        ;;
+    *)
+        # use the path as-is
+        export VIRTUAL_ENV=/Users/kunaldhanda/DeepSeek/multi_model_env
+        ;;
+esac
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/"bin":$PATH"
+export PATH
+
+VIRTUAL_ENV_PROMPT=multi_model_env
+export VIRTUAL_ENV_PROMPT
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="("multi_model_env") ${PS1:-}"
+    export PS1
+fi
+
+# Call hash to forget past commands. Without forgetting
+# past commands the $PATH changes we made may not be respected
+hash -r 2> /dev/null

multi_model_env/bin/activate.csh

@@ -0,0 +1,27 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV /Users/kunaldhanda/DeepSeek/multi_model_env
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/"bin":$PATH"
+setenv VIRTUAL_ENV_PROMPT multi_model_env
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "("multi_model_env") $prompt:q"
+endif
+
+alias pydoc python -m pydoc
+
+rehash

multi_model_env/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/). You cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV /Users/kunaldhanda/DeepSeek/multi_model_env
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/"bin $PATH
+set -gx VIRTUAL_ENV_PROMPT multi_model_env
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s(%s)%s " (set_color 4B8BBE) multi_model_env (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end

multi_model_env/bin/diffusers-cli

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from diffusers.commands.diffusers_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/f2py

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/hf

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from huggingface_hub.cli.hf import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/huggingface-cli

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from huggingface_hub.commands.huggingface_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/isympy

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from isympy import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/normalizer

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from charset_normalizer import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli.cli_detect())

multi_model_env/bin/numpy-config

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy._configtool import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/pip

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/pip3

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/pip3.13

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from pip._internal.cli.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/tiny-agents

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from huggingface_hub.inference._mcp.cli import app
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(app())

multi_model_env/bin/torchfrtrace

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tools.flight_recorder.fr_trace import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/torchrun

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from torch.distributed.run import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/tqdm

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tqdm.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/transformers

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from transformers.commands.transformers_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

multi_model_env/bin/transformers-cli

@@ -0,0 +1,8 @@
+#!/Users/kunaldhanda/DeepSeek/multi_model_env/bin/python3.13
+# -*- coding: utf-8 -*-
+import re
+import sys
+from transformers.commands.transformers_cli import main_cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main_cli())

multi_model_env/lib/python3.13/site-packages/MarkupSafe-3.0.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

multi_model_env/lib/python3.13/site-packages/MarkupSafe-3.0.2.dist-info/LICENSE.txt

@@ -0,0 +1,28 @@
+Copyright 2010 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

multi_model_env/lib/python3.13/site-packages/MarkupSafe-3.0.2.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.1
+Name: MarkupSafe
+Version: 3.0.2
+Summary: Safely add untrusted strings to HTML/XML markup.
+Maintainer-email: Pallets <contact@palletsprojects.com>
+License: Copyright 2010 Pallets
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are
+        met:
+        
+        1.  Redistributions of source code must retain the above copyright
+            notice, this list of conditions and the following disclaimer.
+        
+        2.  Redistributions in binary form must reproduce the above copyright
+            notice, this list of conditions and the following disclaimer in the
+            documentation and/or other materials provided with the distribution.
+        
+        3.  Neither the name of the copyright holder nor the names of its
+            contributors may be used to endorse or promote products derived from
+            this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+        "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+        LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+        PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+        HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+        SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+        TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+        PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+        LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+        NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+        SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://markupsafe.palletsprojects.com/
+Project-URL: Changes, https://markupsafe.palletsprojects.com/changes/
+Project-URL: Source, https://github.com/pallets/markupsafe/
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+# MarkupSafe
+
+MarkupSafe implements a text object that escapes characters so it is
+safe to use in HTML and XML. Characters that have special meanings are
+replaced so that they display as the actual characters. This mitigates
+injection attacks, meaning untrusted user input can safely be displayed
+on a page.
+
+
+## Examples
+
+```pycon
+>>> from markupsafe import Markup, escape
+
+>>> # escape replaces special characters and wraps in Markup
+>>> escape("<script>alert(document.cookie);</script>")
+Markup('&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
+
+>>> # wrap in Markup to mark text "safe" and prevent escaping
+>>> Markup("<strong>Hello</strong>")
+Markup('<strong>hello</strong>')
+
+>>> escape(Markup("<strong>Hello</strong>"))
+Markup('<strong>hello</strong>')
+
+>>> # Markup is a str subclass
+>>> # methods and operators escape their arguments
+>>> template = Markup("Hello <em>{name}</em>")
+>>> template.format(name='"World"')
+Markup('Hello <em>&#34;World&#34;</em>')
+```
+
+## Donate
+
+The Pallets organization develops and supports MarkupSafe and other
+popular packages. In order to grow the community of contributors and
+users, and allow the maintainers to devote more time to the projects,
+[please donate today][].
+
+[please donate today]: https://palletsprojects.com/donate

multi_model_env/lib/python3.13/site-packages/MarkupSafe-3.0.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+MarkupSafe-3.0.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+MarkupSafe-3.0.2.dist-info/LICENSE.txt,sha256=SJqOEQhQntmKN7uYPhHg9-HTHwvY-Zp5yESOf_N9B-o,1475
+MarkupSafe-3.0.2.dist-info/METADATA,sha256=aAwbZhSmXdfFuMM-rEHpeiHRkBOGESyVLJIuwzHP-nw,3975
+MarkupSafe-3.0.2.dist-info/RECORD,,
+MarkupSafe-3.0.2.dist-info/WHEEL,sha256=EhaGmhgTZV8uqhZxBmQmxqlBexDOCFpUXsFLjK8lF9g,109
+MarkupSafe-3.0.2.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
+markupsafe/__init__.py,sha256=sr-U6_27DfaSrj5jnHYxWN-pvhM27sjlDplMDPZKm7k,13214
+markupsafe/__pycache__/__init__.cpython-313.pyc,,
+markupsafe/__pycache__/_native.cpython-313.pyc,,
+markupsafe/_native.py,sha256=hSLs8Jmz5aqayuengJJ3kdT5PwNpBWpKrmQSdipndC8,210
+markupsafe/_speedups.c,sha256=O7XulmTo-epI6n2FtMVOrJXl8EAaIwD2iNYmBI5SEoQ,4149
+markupsafe/_speedups.cpython-313-darwin.so,sha256=zqa2NWhnDkGCuJVPBpLRKADVKQXphH3cRvm6rY8Hvds,50624
+markupsafe/_speedups.pyi,sha256=ENd1bYe7gbBUf2ywyYWOGUpnXOHNJ-cgTNqetlW8h5k,41
+markupsafe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

multi_model_env/lib/python3.13/site-packages/MarkupSafe-3.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.2.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-macosx_11_0_arm64
+

multi_model_env/lib/python3.13/site-packages/MarkupSafe-3.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+markupsafe

multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libavif.16.3.0.dylib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:173bc240d1d7ba7cc6fbd4769a942e5743dfe3d5c60f5d1cdf6bfac1c23e3b5b
+size 2999728

multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libbrotlicommon.1.1.0.dylib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9de349e2275ea9702e3f69ee5bae2645e91f69c0474d6674e0b126ebe3a6d305
+size 201200

multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libbrotlidec.1.1.0.dylib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:296c21f63059fbe2c426b4abfe7ed9274797a5bff875bd58dd75e362c1121c56
+size 104576

multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libfreetype.6.dylib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25662cfcc8b01db700126023a5e4e032a06d3f08c863899a53eda73d0e37dd65
+size 1208336

multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libharfbuzz.0.dylib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74be7efca5f46967668a99acc7eb2b52f4d7d769b5e96d3a70242ae90bddb50e
+size 1772960

multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/libjpeg.62.4.0.dylib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3738d4c83621823e877e389de5c311e3923cef2ed6faf8af613b9c1ab1908ac9
+size 637088

multi_model_env/lib/python3.13/site-packages/PIL/.dylibs/liblcms2.2.dylib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b42c5cb99e069f860382cebe75034b23d5e8dfe979c1b3715790872d0395b2f8
+size 557776