PraisonAI 0.0.58__tar.gz → 0.0.59__tar.gz

{praisonai-0.0.58 → praisonai-0.0.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PraisonAI
-Version: 0.0.58
+Version: 0.0.59
 Summary: PraisonAI application combines AutoGen and CrewAI or similar frameworks into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customization, and efficient human-agent collaboration.
 Author: Mervin Praison
 Requires-Python: >=3.10,<3.13
@@ -17,6 +17,7 @@ Provides-Extra: cohere
 Provides-Extra: google
 Provides-Extra: gradio
 Provides-Extra: openai
+Provides-Extra: train
 Provides-Extra: ui
 Requires-Dist: agentops (>=0.2.6) ; extra == "agentops"
 Requires-Dist: aiosqlite (>=0.20.0) ; extra == "chat" or extra == "code"

{praisonai-0.0.58 → praisonai-0.0.59}/praisonai/cli.py

@@ -12,7 +12,9 @@ import argparse
 from .auto import AutoGenerator
 from .agents_generator import AgentsGenerator
 from .inbuilt_tools import *
+from .inc.config import generate_config
 import shutil
+import subprocess
 import logging
 logging.basicConfig(level=os.environ.get('LOGLEVEL', 'INFO'), format='%(asctime)s - %(levelname)s - %(message)s')
 
@@ -27,6 +29,34 @@ try:
     GRADIO_AVAILABLE = True
 except ImportError:
     GRADIO_AVAILABLE = False
+    
+def stream_subprocess(command, env=None):
+    """
+    Execute a subprocess command and stream the output to the terminal in real-time.
+
+    Args:
+        command (list): A list containing the command and its arguments.
+        env (dict, optional): Environment variables for the subprocess.
+    """
+    process = subprocess.Popen(
+        command,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+        universal_newlines=True,
+        env=env
+    )
+
+    for line in iter(process.stdout.readline, ''):
+        print(line, end='')
+        sys.stdout.flush()  # Ensure output is flushed immediately
+
+    process.stdout.close()
+    return_code = process.wait()
+
+    if return_code != 0:
+        raise subprocess.CalledProcessError(return_code, command)
 
 class PraisonAI:
     def __init__(self, agent_file="agents.yaml", framework="", auto=False, init=False, agent_yaml=None):
@@ -99,6 +129,57 @@ class PraisonAI:
             self.create_code_interface()
             return
         
+        if args.agent_file == 'train':
+            package_root = os.path.dirname(os.path.abspath(__file__))
+            config_yaml_destination = os.path.join(os.getcwd(), 'config.yaml')
+
+            # Create config.yaml only if it doesn't exist or --model or --dataset is provided
+            if not os.path.exists(config_yaml_destination) or args.model or args.dataset:
+                config = generate_config(
+                    model_name=args.model,
+                    hf_model_name=args.hf,
+                    ollama_model_name=args.ollama,
+                    dataset=[{
+                        "name": args.dataset
+                    }]
+                )
+                with open('config.yaml', 'w') as f:
+                    yaml.dump(config, f, default_flow_style=False, indent=2) 
+
+            # Overwrite huggingface_save and ollama_save if --hf or --ollama are provided 
+            if args.hf:
+                config["huggingface_save"] = "true"
+            if args.ollama:
+                config["ollama_save"] = "true"
+
+            if 'init' in sys.argv:
+                from praisonai.setup.setup_conda_env import main as setup_conda_main
+                setup_conda_main()
+                print("All packages installed")
+                return
+
+            try:
+                result = subprocess.check_output(['conda', 'env', 'list'])
+                if 'praison_env' in result.decode('utf-8'):
+                    print("Conda environment 'praison_env' found.")
+                else:
+                    raise subprocess.CalledProcessError(1, 'grep')
+            except subprocess.CalledProcessError:
+                print("Conda environment 'praison_env' not found. Setting it up...")
+                from praisonai.setup.setup_conda_env import main as setup_conda_main
+                setup_conda_main()
+                print("All packages installed.")
+
+            train_args = sys.argv[2:]  # Get all arguments after 'train'
+            train_script_path = os.path.join(package_root, 'train.py')
+            
+            # Set environment variables
+            env = os.environ.copy()
+            env['PYTHONUNBUFFERED'] = '1'
+            
+            stream_subprocess(['conda', 'run', '--no-capture-output', '--name', 'praison_env', 'python', '-u', train_script_path, 'train'] + train_args, env=env)
+            return
+        
         invocation_cmd = "praisonai"
         version_string = f"PraisonAI version {__version__}"
         
@@ -169,7 +250,11 @@ class PraisonAI:
         parser.add_argument("--auto", nargs=argparse.REMAINDER, help="Enable auto mode and pass arguments for it")
         parser.add_argument("--init", nargs=argparse.REMAINDER, help="Enable auto mode and pass arguments for it")
         parser.add_argument("agent_file", nargs="?", help="Specify the agent file")
-        parser.add_argument("--deploy", action="store_true", help="Deploy the application")  # New argument
+        parser.add_argument("--deploy", action="store_true", help="Deploy the application") 
+        parser.add_argument("--model", type=str, help="Model name")
+        parser.add_argument("--hf", type=str, help="Hugging Face model name")
+        parser.add_argument("--ollama", type=str, help="Ollama model name")
+        parser.add_argument("--dataset", type=str, help="Dataset name for training", default="yahma/alpaca-cleaned")
         args, unknown_args = parser.parse_known_args()
 
         if unknown_args and unknown_args[0] == '-b' and unknown_args[1] == 'api:app':

{praisonai-0.0.58 → praisonai-0.0.59}/praisonai/deploy.py

@@ -56,7 +56,7 @@ class CloudDeployer:
             file.write("FROM python:3.11-slim\n")
             file.write("WORKDIR /app\n")
             file.write("COPY . .\n")
-            file.write("RUN pip install flask praisonai==0.0.58 gunicorn markdown\n")
+            file.write("RUN pip install flask praisonai==0.0.59 gunicorn markdown\n")
             file.write("EXPOSE 8080\n")
             file.write('CMD ["gunicorn", "-b", "0.0.0.0:8080", "api:app"]\n')
             

praisonai-0.0.59/praisonai/inc/config.py

@@ -0,0 +1,96 @@
+def generate_config(
+    ollama_save=None,
+    huggingface_save=None,
+    train=None,
+    model_name=None,
+    hf_model_name=None,
+    ollama_model_name=None,
+    model_parameters=None,
+    max_seq_length=None,
+    load_in_4bit=None,
+    lora_r=None,
+    lora_target_modules=None,
+    lora_alpha=None,
+    lora_dropout=None,
+    lora_bias=None,
+    use_gradient_checkpointing=None,
+    random_state=None,
+    use_rslora=None,
+    loftq_config=None,
+    dataset=None,
+    dataset_text_field=None,
+    dataset_num_proc=None,
+    packing=None,
+    per_device_train_batch_size=None,
+    gradient_accumulation_steps=None,
+    warmup_steps=None,
+    num_train_epochs=None,
+    max_steps=None,
+    learning_rate=None,
+    logging_steps=None,
+    optim=None,
+    weight_decay=None,
+    lr_scheduler_type=None,
+    seed=None,
+    output_dir=None,
+    quantization_method=None
+):
+    """Generates the configuration for PraisonAI with dynamic overrides."""
+
+    config = {
+        "ollama_save": ollama_save or "true",
+        "huggingface_save": huggingface_save or "true",
+        "train": train or "true",
+
+        "model_name": model_name or "unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit",
+        "hf_model_name": hf_model_name or "mervinpraison/llama-3.1-tamilan-8B-test",
+        "ollama_model": ollama_model_name or "mervinpraison/llama3.1-tamilan-test",
+        "model_parameters": model_parameters or "8b",
+
+        "dataset": dataset or [
+            {
+                "name": "yahma/alpaca-cleaned",
+                "split_type": "train",
+                "processing_func": "format_prompts",
+                "rename": {"input": "input", "output": "output", "instruction": "instruction"},
+                "filter_data": False,
+                "filter_column_value": "id",
+                "filter_value": "alpaca",
+                "num_samples": 20000
+            }
+        ],
+
+        "dataset_text_field": dataset_text_field or "text",
+        "dataset_num_proc": dataset_num_proc or 2,
+        "packing": packing or False,
+
+        "max_seq_length": max_seq_length or 2048,
+        "load_in_4bit": load_in_4bit or True,
+        "lora_r": lora_r or 16,
+        "lora_target_modules": lora_target_modules or [
+            "q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"
+        ],
+        "lora_alpha": lora_alpha or 16,
+        "lora_dropout": lora_dropout or 0,
+        "lora_bias": lora_bias or "none",
+        "use_gradient_checkpointing": use_gradient_checkpointing or "unsloth",
+        "random_state": random_state or 3407,
+        "use_rslora": use_rslora or False,
+        "loftq_config": loftq_config or None,
+
+        "per_device_train_batch_size": per_device_train_batch_size or 2,
+        "gradient_accumulation_steps": gradient_accumulation_steps or 2,
+        "warmup_steps": warmup_steps or 5,
+        "num_train_epochs": num_train_epochs or 1,
+        "max_steps": max_steps or 10,
+        "learning_rate": learning_rate or 2.0e-4,
+        "logging_steps": logging_steps or 1,
+        "optim": optim or "adamw_8bit",
+        "weight_decay": weight_decay or 0.01,
+        "lr_scheduler_type": lr_scheduler_type or "linear",
+        "seed": seed or 3407,
+        "output_dir": output_dir or "outputs",
+
+        "quantization_method": quantization_method or ["q4_k_m"]
+    }
+    return config

praisonai-0.0.59/praisonai/setup/build.py

@@ -0,0 +1,21 @@
+import subprocess
+import sys
+import os
+
+def build(setup_kwargs):
+    try:
+        # Get the directory of the current script
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        
+        # Construct the path to post_install.py
+        post_install_script = os.path.join(script_dir, 'post_install.py')
+        
+        # Run the post_install.py script
+        subprocess.check_call([sys.executable, post_install_script])
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while running the post-install script: {e}")
+        sys.exit(1)
+    return setup_kwargs
+
+if __name__ == "__main__":
+    build({})

praisonai-0.0.59/praisonai/setup/config.yaml

@@ -0,0 +1,60 @@
+ollama_save: "true"
+huggingface_save: "true"
+train: "true"
+
+model_name: "unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit"
+hf_model_name: "mervinpraison/llama-3.1-tamilan-8B-test"
+ollama_model: "mervinpraison/llama3.1-tamilan-test"
+model_parameters: "8b"
+
+max_seq_length: 2048
+load_in_4bit: true
+lora_r: 16
+lora_target_modules:
+  - "q_proj"
+  - "k_proj"
+  - "v_proj"
+  - "o_proj"
+  - "gate_proj"
+  - "up_proj"
+  - "down_proj"
+lora_alpha: 16
+lora_dropout: 0
+lora_bias: "none"
+use_gradient_checkpointing: "unsloth"
+random_state: 3407
+use_rslora: false
+loftq_config: null
+
+dataset:
+  - name: "yahma/alpaca-cleaned"
+    split_type: "train"
+    processing_func: "format_prompts"
+    rename:
+      input: "input"
+      output: "output"
+      instruction: "instruction"
+    filter_data: false
+    filter_column_value: "id"
+    filter_value: "alpaca"
+    num_samples: 20000
+
+dataset_text_field: "text"
+dataset_num_proc: 2
+packing: false
+
+per_device_train_batch_size: 2
+gradient_accumulation_steps: 2
+warmup_steps: 5
+num_train_epochs: 1
+max_steps: 10
+learning_rate: 2.0e-4
+logging_steps: 1
+optim: "adamw_8bit"
+weight_decay: 0.01
+lr_scheduler_type: "linear"
+seed: 3407
+output_dir: "outputs"
+
+quantization_method: 
+  - "q4_k_m"

praisonai-0.0.59/praisonai/setup/post_install.py

@@ -0,0 +1,20 @@
+import subprocess
+import sys
+import os
+
+def main():
+    try:
+        # Get the absolute path of the current file 
+        current_file = os.path.abspath(__file__)
+        
+        # Get the directory of the current file
+        script_dir = os.path.dirname(current_file) 
+        
+        # Construct the path to setup_conda_env.py
+        setup_script = os.path.join(script_dir, 'setup_conda_env.py')
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while running the setup script: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

praisonai-0.0.59/praisonai/setup/setup_conda_env.py

@@ -0,0 +1,25 @@
+import subprocess
+import os
+import sys
+import platform
+
+def main():
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    script_path = os.path.join(script_dir, 'setup_conda_env.sh')
+    
+    if platform.system() == 'Windows':
+        print("Windows detected. Please run the setup_conda_env.sh script manually in Git Bash or WSL.")
+        print(f"Script location: {script_path}")
+        sys.exit(1)
+    
+    try:
+        subprocess.check_call(['bash', script_path])
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while running the setup script: {e}")
+        print("Setup failed. Please check the error message above and try to resolve the issue.")
+        sys.exit(1)
+    
+    print("Conda environment setup completed successfully!")
+
+if __name__ == "__main__":
+    main()

praisonai-0.0.59/praisonai/setup/setup_conda_env.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+
+# Detect OS and architecture
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    # macOS
+    if [[ $(uname -m) == 'arm64' ]]; then
+        MINICONDA_URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh"
+    else
+        MINICONDA_URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh"
+    fi
+elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+    # Linux
+    MINICONDA_URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh"
+elif [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
+    # Windows
+    MINICONDA_URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe"
+    echo "Windows detected. Please run this script in Git Bash or WSL."
+    exit 1
+else
+    echo "Unsupported operating system: $OSTYPE"
+    exit 1
+fi
+
+# Check if conda is already installed
+if ! command -v conda &> /dev/null; then
+    echo "Conda is not installed. Installing Miniconda..."
+    wget $MINICONDA_URL -O ~/miniconda.sh
+    bash ~/miniconda.sh -b -p $HOME/miniconda
+    source $HOME/miniconda/bin/activate
+    conda init
+else
+    echo "Conda is already installed."
+fi
+
+# Create and activate the Conda environment
+ENV_NAME="praison_env"
+if conda info --envs | grep -q $ENV_NAME; then
+    echo "Environment $ENV_NAME already exists. Recreating..."
+    conda env remove -y -n $ENV_NAME  # Remove existing environment
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        # macOS (both Intel and M1/M2)
+        conda create --name $ENV_NAME python=3.10 pytorch=2.3.0 -c pytorch -y
+    elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+        # Linux
+        conda create --name $ENV_NAME python=3.10 pytorch=2.3.0 cudatoolkit=11.8 -c pytorch -c nvidia -y
+    fi
+    # conda activate $ENV_NAME
+else
+    echo "Creating new environment $ENV_NAME..."
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        # macOS (both Intel and M1/M2)
+        conda create --name $ENV_NAME python=3.10 pytorch=2.3.0 -c pytorch -y
+    elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+        # Linux
+        conda create --name $ENV_NAME python=3.10 pytorch=2.3.0 cudatoolkit=11.8 -c pytorch -c nvidia -y
+    fi
+    # conda activate $ENV_NAME
+fi
+
+# source $HOME/miniconda/bin/activate $ENV_NAME
+
+# Get full path of pip
+PIP_FULL_PATH=$(conda run -n $ENV_NAME which pip)
+
+# Install other packages within the activated environment
+# Use PIP_FULL_PATH to run pip commands
+$PIP_FULL_PATH install --upgrade pip 
+$PIP_FULL_PATH install "xformers==0.0.26.post1"
+$PIP_FULL_PATH install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git@4e570be9ae4ced8cdc64e498125708e34942befc"
+$PIP_FULL_PATH install --no-deps "trl<0.9.0" peft accelerate bitsandbytes 
+
+echo "Setup completed successfully!"

praisonai-0.0.59/praisonai/train.py

@@ -0,0 +1,276 @@
+import subprocess
+import os
+import sys
+import yaml
+import torch
+import shutil
+from transformers import TextStreamer
+from unsloth import FastLanguageModel, is_bfloat16_supported
+from trl import SFTTrainer
+from transformers import TrainingArguments
+from datasets import load_dataset, concatenate_datasets, Dataset
+from psutil import virtual_memory
+
+class train:
+    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, self.tokenizer = None, None
+
+    def load_config(self, path):
+        with open(path, "r") as file:
+            self.config = yaml.safe_load(file)
+
+    def print_system_info(self):
+        print(f"PyTorch version: {torch.__version__}")
+        print(f"CUDA version: {torch.version.cuda}")
+        if torch.cuda.is_available():
+            device_capability = torch.cuda.get_device_capability()
+            print(f"CUDA Device Capability: {device_capability}")
+        else:
+            print("CUDA is not available")
+
+        python_version = sys.version
+        pip_version = subprocess.check_output(['pip', '--version']).decode().strip()
+        python_path = sys.executable
+        pip_path = subprocess.check_output(['which', 'pip']).decode().strip()
+        print(f"Python Version: {python_version}")
+        print(f"Pip Version: {pip_version}")
+        print(f"Python Path: {python_path}")
+        print(f"Pip Path: {pip_path}")
+
+    def check_gpu(self):
+        gpu_stats = torch.cuda.get_device_properties(0)
+        print(f"GPU = {gpu_stats.name}. Max memory = {round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)} GB.")
+
+    def check_ram(self):
+        ram_gb = virtual_memory().total / 1e9
+        print('Your runtime has {:.1f} gigabytes of available RAM\n'.format(ram_gb))
+        if ram_gb < 20:
+            print('Not using a high-RAM runtime')
+        else:
+            print('You are using a high-RAM runtime!')
+
+    # def install_packages(self):
+    #     subprocess.run(["pip", "install", "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git@4e570be9ae4ced8cdc64e498125708e34942befc"])
+    #     subprocess.run(["pip", "install", "--no-deps", "trl<0.9.0", "peft==0.12.0", "accelerate==0.33.0", "bitsandbytes==0.43.3"])
+
+    def prepare_model(self):
+        self.model, self.tokenizer = FastLanguageModel.from_pretrained(
+            model_name=self.config["model_name"],
+            max_seq_length=self.config["max_seq_length"],
+            dtype=None,
+            load_in_4bit=self.config["load_in_4bit"]
+        )
+        self.model = FastLanguageModel.get_peft_model(
+            self.model,
+            r=self.config["lora_r"],
+            target_modules=self.config["lora_target_modules"],
+            lora_alpha=self.config["lora_alpha"],
+            lora_dropout=self.config["lora_dropout"],
+            bias=self.config["lora_bias"],
+            use_gradient_checkpointing=self.config["use_gradient_checkpointing"],
+            random_state=self.config["random_state"],
+            use_rslora=self.config["use_rslora"],
+            loftq_config=self.config["loftq_config"],
+        )
+
+    def process_dataset(self, dataset_info):
+        dataset_name = dataset_info["name"]
+        split_type = dataset_info.get("split_type", "train")
+        processing_func = getattr(self, dataset_info.get("processing_func", "format_prompts"))
+        rename = dataset_info.get("rename", {})
+        filter_data = dataset_info.get("filter_data", False)
+        filter_column_value = dataset_info.get("filter_column_value", "id")
+        filter_value = dataset_info.get("filter_value", "alpaca")
+        num_samples = dataset_info.get("num_samples", 20000)
+
+        dataset = load_dataset(dataset_name, split=split_type)
+
+        if rename:
+            dataset = dataset.rename_columns(rename)
+        if filter_data:
+            dataset = dataset.filter(lambda example: filter_value in example[filter_column_value]).shuffle(seed=42).select(range(num_samples))
+        dataset = dataset.map(processing_func, batched=True)
+        return dataset
+
+    def format_prompts(self, examples):
+        alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+
+        ### Instruction:
+        {}
+
+        ### Input:
+        {}
+
+        ### Response:
+        {}"""
+        texts = [alpaca_prompt.format(ins, inp, out) + self.tokenizer.eos_token for ins, inp, out in zip(examples["instruction"], examples["input"], examples["output"])]
+        return {"text": texts}
+
+    def load_datasets(self):
+        datasets = []
+        for dataset_info in self.config["dataset"]:
+            datasets.append(self.process_dataset(dataset_info))
+        return concatenate_datasets(datasets)
+
+    def train_model(self):
+        dataset = self.load_datasets()
+        trainer = SFTTrainer(
+            model=self.model,
+            tokenizer=self.tokenizer,
+            train_dataset=dataset,
+            dataset_text_field=self.config["dataset_text_field"],
+            max_seq_length=self.config["max_seq_length"],
+            dataset_num_proc=self.config["dataset_num_proc"],
+            packing=self.config["packing"],
+            args=TrainingArguments(
+                per_device_train_batch_size=self.config["per_device_train_batch_size"],
+                gradient_accumulation_steps=self.config["gradient_accumulation_steps"],
+                warmup_steps=self.config["warmup_steps"],
+                num_train_epochs=self.config["num_train_epochs"],
+                max_steps=self.config["max_steps"],
+                learning_rate=self.config["learning_rate"],
+                fp16=not is_bfloat16_supported(),
+                bf16=is_bfloat16_supported(),
+                logging_steps=self.config["logging_steps"],
+                optim=self.config["optim"],
+                weight_decay=self.config["weight_decay"],
+                lr_scheduler_type=self.config["lr_scheduler_type"],
+                seed=self.config["seed"],
+                output_dir=self.config["output_dir"],
+            ),
+        )
+        trainer.train()
+        self.model.save_pretrained("lora_model") # Local saving
+        self.tokenizer.save_pretrained("lora_model")
+
+    def inference(self, instruction, input_text):
+        FastLanguageModel.for_inference(self.model)
+        alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
+
+        ### Instruction:
+        {}
+
+        ### Input:
+        {}
+
+        ### Response:
+        {}"""
+        inputs = self.tokenizer([alpaca_prompt.format(instruction, input_text, "")], return_tensors="pt").to("cuda")
+        outputs = self.model.generate(**inputs, max_new_tokens=64, use_cache=True)
+        print(self.tokenizer.batch_decode(outputs))
+        
+    def load_model(self):
+        """Loads the model and tokenizer using the FastLanguageModel library."""
+        from unsloth import FastLanguageModel
+        model, tokenizer = FastLanguageModel.from_pretrained(
+            model_name=self.config["output_dir"],
+            max_seq_length=2048,
+            dtype=None,
+            load_in_4bit=self.config["load_in_4bit"],
+        )
+        return model, tokenizer
+
+    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.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.tokenizer,
+            quantization_method=self.config["quantization_method"],
+            token=os.getenv('HF_TOKEN')
+        )
+    
+    def save_model_gguf(self):
+        self.model.save_pretrained_gguf(
+            self.config["hf_model_name"],
+            self.tokenizer,
+            quantization_method="q4_k_m"
+        )
+
+    def prepare_modelfile_content(self):
+        output_model = self.config["hf_model_name"]
+        gguf_path = f"{output_model}/unsloth.Q4_K_M.gguf"
+
+        # Check if the GGUF file exists. If not, generate it ## TODO Multiple Quantisation other than Q4_K_M.gguf
+        if not os.path.exists(gguf_path):
+            self.model, self.tokenizer = self.load_model()
+            self.save_model_gguf()
+        return f"""FROM {output_model}/unsloth.Q4_K_M.gguf
+
+TEMPLATE \"\"\"Below are some instructions that describe some tasks. Write responses that appropriately complete each request.{{{{ if .Prompt }}}}
+
+### Instruction:
+{{{{ .Prompt }}}}
+
+{{{{ end }}}}### Response:
+{{{{ .Response }}}}\"\"\"
+
+PARAMETER stop ""
+PARAMETER stop ""
+PARAMETER stop ""
+PARAMETER stop ""
+PARAMETER stop "<|reserved_special_token_"
+"""
+
+    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()
+        # self.install_packages()
+        if self.config.get("train", "true").lower() == "true":
+            self.prepare_model()
+            self.train_model()
+
+        if self.config.get("huggingface_save", "true").lower() == "true":
+            self.model, self.tokenizer = self.load_model()
+            self.save_model_merged()
+
+        if self.config.get("huggingface_save_gguf", "true").lower() == "true":
+            self.model, self.tokenizer = self.load_model()
+            self.push_model_gguf()
+            
+        # if self.config.get("save_gguf", "true").lower() == "true": ## TODO
+        #     self.model, self.tokenizer = self.load_model()
+        #     self.save_model_gguf()
+        
+        # if self.config.get("save_merged", "true").lower() == "true": ## TODO
+        #     self.model, self.tokenizer = self.load_model()
+        #     self.save_model_merged()
+
+        if self.config.get("ollama_save", "true").lower() == "true":
+            self.create_and_push_ollama_model()
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description='PraisonAI Training Script')
+    parser.add_argument('command', choices=['train'], help='Command to execute')
+    parser.add_argument('--config', default='config.yaml', help='Path to configuration file')
+    args = parser.parse_args()
+
+    if args.command == 'train':
+        ai = train(config_path=args.config)
+        ai.run()
+
+
+if __name__ == '__main__':
+    main()

{praisonai-0.0.58 → praisonai-0.0.59}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "PraisonAI"
-version = "0.0.58"
+version = "0.0.59"
 description = "PraisonAI application combines AutoGen and CrewAI or similar frameworks into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customization, and efficient human-agent collaboration."
 authors = ["Mervin Praison"]
 license = ""
@@ -20,7 +20,7 @@ pyautogen = ">=0.2.19"
 crewai = ">=0.32.0"
 markdown = ">=3.5"
 praisonai-tools = ">=0.0.7"
-pyparsing = ">=3.0.0" # Added to fix a colab issue. Temp Fix.
+pyparsing = ">=3.0.0"
 chainlit = {version = "^1.1.301", optional = true}
 gradio = {version = ">=4.26.0", optional = true}
 flask = {version = ">=3.0.0", optional = true}
@@ -89,6 +89,8 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.scripts]
 praisonai = "praisonai.__main__:main"
+setup-conda-env = "setup.setup_conda_env:main"
+post-install = "setup.post_install:main"
 
 [tool.poetry.extras]
 ui = ["chainlit"]
@@ -100,4 +102,14 @@ openai = ["langchain-openai"]
 anthropic = ["langchain-anthropic"]
 cohere = ["langchain-cohere"]
 chat = ["chainlit", "litellm", "aiosqlite", "greenlet"]
-code = ["chainlit", "litellm", "aiosqlite", "greenlet"]
+code = ["chainlit", "litellm", "aiosqlite", "greenlet"]
+train = ["setup-conda-env"]
+
+[tool.poetry-dynamic-versioning]
+enable = true
+vcs = "git"
+style = "semver"
+
+[tool.poetry.build]
+generate-setup-file = false
+script = "praisonai/setup/post_install.py"