PraisonAI 2.0.53__cp311-cp311-macosx_15_0_arm64.whl → 2.2.16__cp311-cp311-macosx_15_0_arm64.whl

praisonai/train_vision.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+This script finetunes a vision language model using Unsloth's fast training framework.
+It supports vision tasks by converting raw image-caption samples into a conversation format, 
+adding vision-specific LoRA adapters, and training using TRL's SFTTrainer with UnslothVisionDataCollator.
+"""
+
+import os
+import sys
+import yaml
+import torch
+import shutil
+import subprocess
+import gc  # For garbage collection
+
+from datasets import load_dataset, concatenate_datasets, Dataset
+from unsloth import FastVisionModel, is_bf16_supported
+from unsloth.trainer import UnslothVisionDataCollator
+from transformers import TrainingArguments
+from trl import SFTTrainer
+from tqdm import tqdm  # Add progress bar
+
+
+class TrainVisionModel:
+    def __init__(self, config_path="config.yaml"):
+        self.load_config(config_path)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.hf_tokenizer = None  # The underlying tokenizer
+
+    def load_config(self, path):
+        with open(path, "r") as file:
+            self.config = yaml.safe_load(file)
+        print("DEBUG: Loaded config:", self.config)
+
+    def print_system_info(self):
+        print("DEBUG: PyTorch version:", torch.__version__)
+        print("DEBUG: CUDA version:", torch.version.cuda)
+        if torch.cuda.is_available():
+            print("DEBUG: CUDA Device Capability:", torch.cuda.get_device_capability())
+        else:
+            print("DEBUG: CUDA is not available")
+        print("DEBUG: Python Version:", sys.version)
+        print("DEBUG: Python Path:", sys.executable)
+
+    def check_gpu(self):
+        gpu_stats = torch.cuda.get_device_properties(0)
+        print(f"DEBUG: GPU = {gpu_stats.name}. Max memory = {round(gpu_stats.total_memory/(1024**3),3)} GB.")
+
+    def check_ram(self):
+        from psutil import virtual_memory
+        ram_gb = virtual_memory().total / 1e9
+        print(f"DEBUG: Your runtime has {ram_gb:.1f} gigabytes of available RAM")
+        if ram_gb < 20:
+            print("DEBUG: Not using a high-RAM runtime")
+        else:
+            print("DEBUG: You are using a high-RAM runtime!")
+
+    def prepare_model(self):
+        print("DEBUG: Preparing vision model and tokenizer...")
+        self.model, original_tokenizer = FastVisionModel.from_pretrained(
+            model_name=self.config["model_name"],
+            load_in_4bit=self.config["load_in_4bit"],
+            use_gradient_checkpointing="unsloth"
+        )
+        print("DEBUG: Vision model and original tokenizer loaded.")
+        
+        # Use the full processor that supports image inputs.
+        self.hf_tokenizer = original_tokenizer
+        
+        # Set pad token if needed
+        if not hasattr(self.hf_tokenizer, 'pad_token') or self.hf_tokenizer.pad_token is None:
+            if hasattr(self.hf_tokenizer, 'eos_token'):
+                self.hf_tokenizer.pad_token = self.hf_tokenizer.eos_token
+            elif hasattr(self.hf_tokenizer, 'bos_token'):
+                self.hf_tokenizer.pad_token = self.hf_tokenizer.bos_token
+        
+        # Set max length
+        if hasattr(self.hf_tokenizer, 'model_max_length'):
+            self.hf_tokenizer.model_max_length = self.config.get("max_seq_length", 2048)
+        
+        # Add vision-specific LoRA adapters
+        self.model = FastVisionModel.get_peft_model(
+            self.model,
+            finetune_vision_layers=self.config.get("finetune_vision_layers", False),
+            finetune_language_layers=self.config.get("finetune_language_layers", True),
+            finetune_attention_modules=self.config.get("finetune_attention_modules", True),
+            finetune_mlp_modules=self.config.get("finetune_mlp_modules", True),
+            r=16,
+            lora_alpha=16,
+            lora_dropout=0,
+            bias="none",
+            random_state=3407,
+            use_rslora=False,
+            loftq_config=None
+        )
+        print("DEBUG: Vision LoRA adapters added.")
+
+    def convert_sample(self, sample):
+        
+        instruction = self.config.get(
+            "vision_instruction",
+            "You are an expert radiographer. Describe accurately what you see in this image."
+        )
+        conversation = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": instruction},
+                    {"type": "image", "image": sample["image"]}
+                ]
+            },
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "text", "text": sample["caption"]}
+                ]
+            },
+        ]
+        
+        return {"messages": conversation}
+
+    def load_datasets(self):
+        all_converted = []
+        for dataset_info in self.config["dataset"]:
+            print("\nDEBUG: Loading vision dataset:", dataset_info)
+            ds = load_dataset(
+                dataset_info["name"], 
+                split=dataset_info.get("split_type", "train")
+            )
+            print("DEBUG: Dataset size:", len(ds))
+            print("DEBUG: First raw sample:", ds[0])
+            print("DEBUG: Dataset features:", ds.features)
+            
+            print("\nDEBUG: Converting dataset to vision conversation format...")
+            converted_ds = [self.convert_sample(sample) for sample in ds]
+            
+            # Debug first converted sample
+            print("\nDEBUG: First converted sample structure:")
+            first = converted_ds[0]
+            print("DEBUG: Message keys:", first["messages"][0]["content"][1].keys())
+            print("DEBUG: Image type in converted:", type(first["messages"][0]["content"][1].get("image")))
+            
+            all_converted.extend(converted_ds)
+        
+        print("\nDEBUG: Combined vision dataset has", len(all_converted), "examples.")
+        return all_converted
+
+    def train_model(self):
+        print("DEBUG: Starting vision training...")
+        raw_dataset = self.load_datasets()
+        
+        # Build training arguments using TrainingArguments
+        training_args = TrainingArguments(
+            per_device_train_batch_size=self.config.get("per_device_train_batch_size", 1),
+            gradient_accumulation_steps=self.config.get("gradient_accumulation_steps", 4),
+            warmup_steps=self.config.get("warmup_steps", 5),
+            max_steps=self.config.get("max_steps", 30),
+            learning_rate=self.config.get("learning_rate", 2e-4),
+            fp16=self.config.get("fp16", not is_bf16_supported()),
+            bf16=self.config.get("bf16", is_bf16_supported()),
+            logging_steps=self.config.get("logging_steps", 1),
+            optim=self.config.get("optim", "adamw_8bit"),
+            weight_decay=self.config.get("weight_decay", 0.01),
+            lr_scheduler_type=self.config.get("lr_scheduler_type", "linear"),
+            seed=self.config.get("seed", 3407),
+            output_dir=self.config.get("output_dir", "outputs"),
+            report_to="none" if not os.getenv("PRAISON_WANDB") else "wandb",
+            remove_unused_columns=False,
+            # Add memory optimization settings
+            gradient_checkpointing=True,
+            max_grad_norm=1.0,
+        )
+        
+        trainer = SFTTrainer(
+            model=self.model,
+            tokenizer=self.hf_tokenizer,
+            data_collator=UnslothVisionDataCollator(self.model, self.hf_tokenizer),
+            train_dataset=raw_dataset,
+            args=training_args,
+            max_seq_length=self.config.get("max_seq_length", 2048),
+            dataset_text_field="",  # Required for vision training
+            dataset_kwargs={"skip_prepare_dataset": True},  # Required for vision training
+            packing=False  # Explicitly set packing to False
+        )
+        print("DEBUG: Beginning vision trainer.train() ...")
+        trainer.train()
+        print("DEBUG: Vision training complete. Saving model and tokenizer locally...")
+        self.model.save_pretrained("lora_vision_model")
+        self.hf_tokenizer.save_pretrained("lora_vision_model")
+        print("DEBUG: Saved vision model and tokenizer to 'lora_vision_model'.")
+
+    def vision_inference(self, instruction, image):
+        FastVisionModel.for_inference(self.model)
+        messages = [
+            {"role": "user", "content": [
+                {"type": "image"},
+                {"type": "text", "text": instruction}
+            ]}
+        ]
+        input_text = self.hf_tokenizer.apply_chat_template(messages, add_generation_prompt=True)
+        inputs = self.hf_tokenizer(
+            image,
+            input_text,
+            add_special_tokens=False,
+            return_tensors="pt"
+        ).to("cuda")
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=128,
+            use_cache=True,
+            temperature=1.5,
+            min_p=0.1
+        )
+        print("DEBUG: Vision inference output:", self.hf_tokenizer.batch_decode(outputs))
+
+    def save_model_merged(self):
+        if os.path.exists(self.config["hf_model_name"]):
+            shutil.rmtree(self.config["hf_model_name"])
+        self.model.push_to_hub_merged(
+            self.config["hf_model_name"],
+            self.hf_tokenizer,
+            save_method="merged_16bit",
+            token=os.getenv("HF_TOKEN")
+        )
+
+    def push_model_gguf(self):
+        self.model.push_to_hub_gguf(
+            self.config["hf_model_name"],
+            self.hf_tokenizer,
+            quantization_method=self.config.get("quantization_method", "q4_k_m"),
+            token=os.getenv("HF_TOKEN")
+        )
+
+    def save_model_gguf(self):
+        self.model.save_pretrained_gguf(
+            self.config["hf_model_name"],
+            self.hf_tokenizer,
+            quantization_method="q4_k_m"
+        )
+
+    def prepare_modelfile_content(self):
+        output_model = self.config["hf_model_name"]
+        
+        template = '''{{- range $index, $_ := .Messages }}<|start_header_id|>{{ .Role }}<|end_header_id|>
+
+{{ .Content }}
+{{- if gt (len (slice $.Messages $index)) 1 }}<|eot_id|>
+{{- else if ne .Role "assistant" }}<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+
+{{ end }}
+{{- end }}'''
+        
+        return f"""FROM {output_model}
+TEMPLATE {template}
+PARAMETER temperature 0.6
+PARAMETER top_p 0.9
+"""
+
+    def create_and_push_ollama_model(self):
+        modelfile_content = self.prepare_modelfile_content()
+        with open("Modelfile", "w") as file:
+            file.write(modelfile_content)
+        subprocess.run(["ollama", "serve"])
+        subprocess.run(["ollama", "create", f"{self.config['ollama_model']}:{self.config['model_parameters']}", "-f", "Modelfile"])
+        subprocess.run(["ollama", "push", f"{self.config['ollama_model']}:{self.config['model_parameters']}"])
+
+    def run(self):
+        self.print_system_info()
+        self.check_gpu()
+        self.check_ram()
+        if self.config.get("train", "true").lower() == "true":
+            self.prepare_model()
+            self.train_model()
+        if self.config.get("huggingface_save", "true").lower() == "true":
+            self.save_model_merged()
+        if self.config.get("huggingface_save_gguf", "true").lower() == "true":
+            self.push_model_gguf()
+        if self.config.get("ollama_save", "true").lower() == "true":
+            self.create_and_push_ollama_model()
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="PraisonAI Vision Training Script")
+    parser.add_argument("command", choices=["train", "inference"], help="Command to execute")
+    parser.add_argument("--config", default="config.yaml", help="Path to configuration file")
+    args = parser.parse_args()
+
+    trainer_obj = TrainVisionModel(config_path=args.config)
+    if args.command == "train":
+        trainer_obj.run()
+    elif args.command == "inference":
+        # For inference, we load a sample image from the first dataset
+        instr = trainer_obj.config.get("vision_instruction", "You are an expert radiographer. Describe accurately what you see in this image.")
+        ds_info = trainer_obj.config["dataset"][0]
+        ds = load_dataset(ds_info["name"], split=ds_info.get("split_type", "train"))
+        sample_image = ds[0]["image"]
+        if trainer_obj.model is None or trainer_obj.hf_tokenizer is None:
+            trainer_obj.prepare_model()
+        trainer_obj.vision_inference(instr, sample_image)
+
+
+if __name__ == "__main__":
+    main() 

praisonai/ui/code.py

@@ -100,7 +100,8 @@ async def start():
     )
     cl.user_session.set("settings", settings)
     await settings.send()
-    gatherer = ContextGatherer()
+    repo_path_to_use = os.environ.get("PRAISONAI_CODE_REPO_PATH", ".")
+    gatherer = ContextGatherer(directory=repo_path_to_use)
     context, token_count, context_tree = gatherer.run()
     msg = cl.Message(content="""Token Count: {token_count},
                                  Files include: \n```bash\n{context_tree}\n"""
@@ -200,7 +201,8 @@ tools = [{
 async def main(message: cl.Message):
     model_name = load_setting("model_name") or os.getenv("MODEL_NAME") or "gpt-4o-mini"
     message_history = cl.user_session.get("message_history", [])
-    gatherer = ContextGatherer()
+    repo_path_to_use = os.environ.get("PRAISONAI_CODE_REPO_PATH", ".")
+    gatherer = ContextGatherer(directory=repo_path_to_use)
     context, token_count, context_tree = gatherer.run()
     now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 

praisonai/ui/sql_alchemy.py

@@ -70,7 +70,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
                 logger.info("SQLAlchemyDataLayer storage client initialized")
         else:
             self.storage_provider = None
-            logger.warn(
+            logger.warning(
                 "SQLAlchemyDataLayer storage client is not initialized and elements will not be persisted!"
             )
 
@@ -98,11 +98,11 @@ class SQLAlchemyDataLayer(BaseDataLayer):
                     return result.rowcount
             except SQLAlchemyError as e:
                 await session.rollback()
-                logger.warn(f"An error occurred: {e}")
+                logger.warning(f"An error occurred: {e}")
                 return None
             except Exception as e:
                 await session.rollback()
-                logger.warn(f"An unexpected error occurred: {e}")
+                logger.warning(f"An unexpected error occurred: {e}")
                 return None
 
     async def get_current_timestamp(self) -> str:
@@ -456,7 +456,7 @@ class SQLAlchemyDataLayer(BaseDataLayer):
             logger.info(f"SQLAlchemy: create_element, element_id = {element.id}")
 
         if not self.storage_provider:
-            logger.warn("SQLAlchemy: create_element error. No storage client!")
+            logger.warning("SQLAlchemy: create_element error. No storage client!")
             return
         if not element.for_id:
             return

praisonai/upload_vision.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+This script handles uploading trained vision models to Hugging Face and Ollama.
+It reads configuration from config.yaml and provides options to upload in different formats.
+"""
+
+import os
+import yaml
+import torch
+import shutil
+import subprocess
+from unsloth import FastVisionModel
+
+class UploadVisionModel:
+    def __init__(self, config_path="config.yaml"):
+        self.load_config(config_path)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.hf_tokenizer = None
+
+    def load_config(self, path):
+        """Load configuration from yaml file."""
+        with open(path, "r") as file:
+            self.config = yaml.safe_load(file)
+        print("DEBUG: Loaded config:", self.config)
+
+    def prepare_model(self):
+        """Load the trained model for uploading."""
+        print("DEBUG: Loading trained model and tokenizer...")
+        self.model, original_tokenizer = FastVisionModel.from_pretrained(
+            model_name=self.config.get("output_dir", "lora_model"),
+            load_in_4bit=self.config.get("load_in_4bit", True)
+        )
+        self.hf_tokenizer = original_tokenizer
+        print("DEBUG: Model and tokenizer loaded successfully.")
+
+    def save_model_merged(self):
+        """Save merged model to Hugging Face Hub."""
+        print(f"DEBUG: Saving merged model to Hugging Face Hub: {self.config['hf_model_name']}")
+        if os.path.exists(self.config["hf_model_name"]):
+            shutil.rmtree(self.config["hf_model_name"])
+        self.model.push_to_hub_merged(
+            self.config["hf_model_name"],
+            self.hf_tokenizer,
+            save_method="merged_16bit",
+            token=os.getenv("HF_TOKEN")
+        )
+        print("DEBUG: Model saved to Hugging Face Hub successfully.")
+
+    def push_model_gguf(self):
+        """Push model in GGUF format to Hugging Face Hub."""
+        print(f"DEBUG: Pushing GGUF model to Hugging Face Hub: {self.config['hf_model_name']}")
+        self.model.push_to_hub_gguf(
+            self.config["hf_model_name"],
+            self.hf_tokenizer,
+            quantization_method=self.config.get("quantization_method", "q4_k_m"),
+            token=os.getenv("HF_TOKEN")
+        )
+        print("DEBUG: GGUF model pushed to Hugging Face Hub successfully.")
+
+    def prepare_modelfile_content(self):
+        """Prepare Ollama modelfile content using Llama 3.2 vision template."""
+        output_model = self.config["hf_model_name"]
+        
+        # Using Llama 3.2 vision template format
+        template = """{{- range $index, $_ := .Messages }}<|start_header_id|>{{ .Role }}<|end_header_id|>
+
+{{ .Content }}
+{{- if gt (len (slice $.Messages $index)) 1 }}<|eot_id|>
+{{- else if ne .Role "assistant" }}<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+
+{{ end }}
+{{- end }}"""
+        
+        # Assemble the modelfile content with Llama 3.2 vision parameters
+        modelfile = f"FROM {output_model}\n"
+        modelfile += "TEMPLATE \"""" + template + "\"""\n"
+        modelfile += "PARAMETER temperature 0.6\n"
+        modelfile += "PARAMETER top_p 0.9\n"
+        return modelfile
+
+    def create_and_push_ollama_model(self):
+        """Create and push model to Ollama."""
+        print(f"DEBUG: Creating Ollama model: {self.config['ollama_model']}:{self.config['model_parameters']}")
+        modelfile_content = self.prepare_modelfile_content()
+        with open("Modelfile", "w") as file:
+            file.write(modelfile_content)
+        
+        print("DEBUG: Starting Ollama server...")
+        subprocess.run(["ollama", "serve"])
+        
+        print("DEBUG: Creating Ollama model...")
+        subprocess.run([
+            "ollama", "create", 
+            f"{self.config['ollama_model']}:{self.config['model_parameters']}", 
+            "-f", "Modelfile"
+        ])
+        
+        print("DEBUG: Pushing model to Ollama...")
+        subprocess.run([
+            "ollama", "push", 
+            f"{self.config['ollama_model']}:{self.config['model_parameters']}"
+        ])
+        print("DEBUG: Model pushed to Ollama successfully.")
+
+    def upload(self, target="all"):
+        """
+        Upload the model to specified targets.
+        Args:
+            target (str): One of 'all', 'huggingface', 'huggingface_gguf', or 'ollama'
+        """
+        self.prepare_model()
+        
+        if target in ["all", "huggingface"]:
+            self.save_model_merged()
+        
+        if target in ["all", "huggingface_gguf"]:
+            self.push_model_gguf()
+            
+        if target in ["all", "ollama"]:
+            self.create_and_push_ollama_model()
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Upload Vision Model to Various Platforms")
+    parser.add_argument("--config", default="config.yaml", help="Path to configuration file")
+    parser.add_argument(
+        "--target", 
+        choices=["all", "huggingface", "huggingface_gguf", "ollama"],
+        default="all",
+        help="Target platform to upload to"
+    )
+    args = parser.parse_args()
+
+    uploader = UploadVisionModel(config_path=args.config)
+    uploader.upload(target=args.target)
+
+if __name__ == "__main__":
+    main()

praisonai-2.2.16.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.3
+Name: PraisonAI
+Version: 2.2.16
+Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
+Author: Mervin Praison
+Requires-Python: >=3.10,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: agentops
+Provides-Extra: anthropic
+Provides-Extra: api
+Provides-Extra: autogen
+Provides-Extra: call
+Provides-Extra: chat
+Provides-Extra: code
+Provides-Extra: cohere
+Provides-Extra: crewai
+Provides-Extra: google
+Provides-Extra: gradio
+Provides-Extra: openai
+Provides-Extra: realtime
+Provides-Extra: ui
+Requires-Dist: PyYAML (>=6.0)
+Requires-Dist: agentops (>=0.3.12) ; extra == "agentops"
+Requires-Dist: aiosqlite (>=0.20.0) ; extra == "chat"
+Requires-Dist: aiosqlite (>=0.20.0) ; extra == "code"
+Requires-Dist: aiosqlite (>=0.20.0) ; extra == "realtime"
+Requires-Dist: aiosqlite (>=0.20.0) ; extra == "ui"
+Requires-Dist: chainlit (==2.5.5) ; extra == "chat"
+Requires-Dist: chainlit (==2.5.5) ; extra == "code"
+Requires-Dist: chainlit (==2.5.5) ; extra == "realtime"
+Requires-Dist: chainlit (==2.5.5) ; extra == "ui"
+Requires-Dist: crawl4ai (>=0.6.0) ; extra == "chat"
+Requires-Dist: crawl4ai (>=0.6.0) ; extra == "code"
+Requires-Dist: crawl4ai (>=0.6.0) ; extra == "realtime"
+Requires-Dist: crewai (>=0.32.0) ; extra == "crewai"
+Requires-Dist: crewai ; extra == "autogen"
+Requires-Dist: duckduckgo_search (>=6.3.0) ; extra == "realtime"
+Requires-Dist: fastapi (>=0.115.0) ; extra == "api"
+Requires-Dist: fastapi (>=0.95.0) ; extra == "call"
+Requires-Dist: flaml[automl] (>=2.3.1) ; extra == "call"
+Requires-Dist: flask (>=3.0.0) ; extra == "api"
+Requires-Dist: gradio (>=4.26.0) ; extra == "gradio"
+Requires-Dist: greenlet (>=3.0.3) ; extra == "chat"
+Requires-Dist: greenlet (>=3.0.3) ; extra == "code"
+Requires-Dist: greenlet (>=3.0.3) ; extra == "realtime"
+Requires-Dist: greenlet (>=3.0.3) ; extra == "ui"
+Requires-Dist: instructor (>=1.3.3)
+Requires-Dist: langchain-anthropic (>=0.3.0) ; extra == "anthropic"
+Requires-Dist: langchain-cohere (>=0.3.0,<0.4.0) ; extra == "cohere"
+Requires-Dist: langchain-google-genai (>=2.1.0) ; extra == "google"
+Requires-Dist: langchain-openai (>=0.2.1,<0.3.0) ; extra == "openai"
+Requires-Dist: litellm (>=1.68.0) ; extra == "chat"
+Requires-Dist: litellm (>=1.68.0) ; extra == "code"
+Requires-Dist: litellm (>=1.68.0) ; extra == "realtime"
+Requires-Dist: markdown (>=3.5)
+Requires-Dist: mcp (>=1.6.0)
+Requires-Dist: openai (>=1.54.0) ; extra == "call"
+Requires-Dist: playwright (>=1.47.0) ; extra == "chat"
+Requires-Dist: playwright (>=1.47.0) ; extra == "code"
+Requires-Dist: plotly (>=5.24.0) ; extra == "realtime"
+Requires-Dist: praisonai-tools (>=0.0.15) ; extra == "autogen"
+Requires-Dist: praisonai-tools (>=0.0.15) ; extra == "crewai"
+Requires-Dist: praisonaiagents (>=0.0.89)
+Requires-Dist: pyautogen (>=0.2.19) ; extra == "autogen"
+Requires-Dist: pydantic (<=2.10.1) ; extra == "chat"
+Requires-Dist: pydantic (<=2.10.1) ; extra == "code"
+Requires-Dist: pydantic (<=2.10.1) ; extra == "ui"
+Requires-Dist: pyngrok (>=1.4.0) ; extra == "call"
+Requires-Dist: pyparsing (>=3.0.0)
+Requires-Dist: python-dotenv (>=0.19.0)
+Requires-Dist: rich (>=13.7)
+Requires-Dist: rich ; extra == "call"
+Requires-Dist: rich ; extra == "chat"
+Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "chat"
+Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "code"
+Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "realtime"
+Requires-Dist: sqlalchemy (>=2.0.36) ; extra == "ui"
+Requires-Dist: tavily-python (==0.5.0) ; extra == "chat"
+Requires-Dist: tavily-python (==0.5.0) ; extra == "code"
+Requires-Dist: tavily-python (==0.5.0) ; extra == "realtime"
+Requires-Dist: twilio (>=7.0.0) ; extra == "call"
+Requires-Dist: uvicorn (>=0.20.0) ; extra == "call"
+Requires-Dist: uvicorn (>=0.34.0) ; extra == "api"
+Requires-Dist: websockets (>=12.0) ; extra == "call"
+Requires-Dist: websockets (>=12.0) ; extra == "realtime"
+Requires-Dist: yfinance (>=0.2.44) ; extra == "realtime"
+Project-URL: Homepage, https://docs.praison.ai
+Project-URL: Repository, https://github.com/mervinpraison/PraisonAI
+Description-Content-Type: text/markdown
+
+# PraisonAI Package
+
+This is the PraisonAI package, which serves as a wrapper for PraisonAIAgents.
+
+It provides a simple and intuitive interface for working with AI agents and their capabilities.
+
+## Directory Structure
+
+The main package code is located in the `praisonai` subdirectory.
+