isa-model 0.0.1__py3-none-any.whl

isa_model/training/image_model/raw_data/pre_processing.py

@@ -0,0 +1,200 @@
+import os
+import cv2
+import logging
+from PIL import Image
+from pathlib import Path
+from tqdm import tqdm
+from concurrent.futures import ProcessPoolExecutor
+import shutil
+from ultralytics import YOLO
+import numpy
+from pillow_heif import register_heif_opener
+
+# Configure logging and PIL settings
+logging.basicConfig(level=logging.INFO)
+Image.MAX_IMAGE_PIXELS = None
+register_heif_opener()  # This enables HEIC support in PIL
+
+COCO_CLASSES = {
+    'person': 0, 'bicycle': 1, 'car': 2, 'motorcycle': 3, 'airplane': 4, 'bus': 5, 'train': 6,
+    'truck': 7, 'boat': 8, 'traffic light': 9, 'fire hydrant': 10, 'stop sign': 11,
+    'parking meter': 12, 'bench': 13, 'bird': 14, 'cat': 15, 'dog': 16, 'horse': 17,
+    'sheep': 18, 'cow': 19, 'elephant': 20, 'bear': 21, 'zebra': 22, 'giraffe': 23,
+    'backpack': 24, 'umbrella': 25, 'handbag': 26, 'tie': 27, 'suitcase': 28, 'frisbee': 29,
+    'skis': 30, 'snowboard': 31, 'sports ball': 32, 'kite': 33, 'baseball bat': 34,
+    'baseball glove': 35, 'skateboard': 36, 'surfboard': 37, 'tennis racket': 38,
+    'bottle': 39, 'wine glass': 40, 'cup': 41, 'fork': 42, 'knife': 43, 'spoon': 44,
+    'bowl': 45, 'banana': 46, 'apple': 47, 'sandwich': 48, 'orange': 49, 'broccoli': 50,
+    'carrot': 51, 'hot dog': 52, 'pizza': 53, 'donut': 54, 'cake': 55, 'chair': 56,
+    'couch': 57, 'potted plant': 58, 'bed': 59, 'dining table': 60, 'toilet': 61,
+    'tv': 62, 'laptop': 63, 'mouse': 64, 'remote': 65, 'keyboard': 66, 'cell phone': 67,
+    'microwave': 68, 'oven': 69, 'toaster': 70, 'sink': 71, 'refrigerator': 72,
+    'book': 73, 'clock': 74, 'vase': 75, 'scissors': 76, 'teddy bear': 77,
+    'hair drier': 78, 'toothbrush': 79
+}
+
+class ImagePreProcessor:
+    def __init__(self, input_dir: str, output_dir: str, target_size: tuple = (512, 512), 
+                 padding: float = 0.3):
+        """
+        Initialize the image preprocessor
+        """
+        self.input_dir = Path(input_dir)
+        self.output_dir = Path(output_dir)
+        self.target_size = target_size
+        self.padding = padding
+        self.supported_formats = {'.jpg', '.jpeg', '.heic', '.png'}
+        
+        # Load YOLO face detection model
+        try:
+            logging.info("Loading YOLO face detection model...")
+            current_dir = Path(__file__).parent  # Get the directory where this script is located
+            model_path = current_dir / "models" / "yolov8n-face.pt"
+            
+            if not os.path.exists(model_path):
+                raise FileNotFoundError(f"Model file not found at {model_path}")
+            self.model = YOLO(str(model_path))  # Convert Path to string for YOLO
+            logging.info("Successfully loaded YOLO face detection model")
+        except Exception as e:
+            logging.error(f"Failed to load YOLO model: {str(e)}")
+            raise
+
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def detect_and_crop_face(self, img) -> tuple:
+        """
+        Detect face in image and return cropped region
+        """
+        cv2_img = cv2.cvtColor(numpy.array(img), cv2.COLOR_RGB2BGR)
+        results = self.model(cv2_img)
+        
+        # Get all face detections
+        detections = results[0].boxes
+        
+        if len(detections) == 0:
+            return False, None
+            
+        # Get coordinates of the first detected face
+        box = detections[0]
+        x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
+        
+        # Add padding
+        width = x2 - x1
+        height = y2 - y1
+        padding_x = int(width * self.padding)
+        padding_y = int(height * self.padding)
+        
+        x1 = max(0, x1 - padding_x)
+        y1 = max(0, y1 - padding_y)
+        x2 = min(img.width, x2 + padding_x)
+        y2 = min(img.height, y2 + padding_y)
+        
+        cropped_img = img.crop((x1, y1, x2, y2))
+        return True, cropped_img
+
+    def process_image(self, image_path: Path) -> tuple:
+        """
+        Process a single image
+        
+        Args:
+            image_path (Path): Path to input image
+            
+        Returns:
+            tuple: (success, message)
+        """
+        try:
+            # Handle HEIC/HEIF files
+            if image_path.suffix.lower() in {'.heic', '.heif'}:
+                try:
+                    with Image.open(image_path) as img:
+                        # Convert HEIC to RGB mode
+                        img = img.convert('RGB')
+                        detected, cropped_img = self.detect_and_crop_face(img)
+                        if not detected:
+                            return False, f"No face detected in {image_path.name}"
+                except Exception as e:
+                    return False, f"Error processing HEIC file {image_path.name}: {str(e)}"
+            else:
+                # Handle other image formats
+                with Image.open(image_path) as img:
+                    if img.mode != 'RGB':
+                        img = img.convert('RGB')
+                    detected, cropped_img = self.detect_and_crop_face(img)
+                    if not detected:
+                        return False, f"No face detected in {image_path.name}"
+            
+            # Process the cropped image
+            aspect_ratio = cropped_img.width / cropped_img.height
+            if aspect_ratio > 1:
+                new_width = self.target_size[0]
+                new_height = int(self.target_size[0] / aspect_ratio)
+            else:
+                new_height = self.target_size[1]
+                new_width = int(self.target_size[1] * aspect_ratio)
+
+            cropped_img = cropped_img.resize((new_width, new_height), Image.LANCZOS)
+            
+            new_img = Image.new('RGB', self.target_size, (0, 0, 0))
+            paste_x = (self.target_size[0] - new_width) // 2
+            paste_y = (self.target_size[1] - new_height) // 2
+            new_img.paste(cropped_img, (paste_x, paste_y))
+            
+            output_path = self.output_dir / f"{image_path.stem}.jpg"
+            new_img.save(output_path, 'JPEG', quality=95)
+            
+            return True, f"Successfully processed {image_path.name}"
+
+        except Exception as e:
+            return False, f"Error processing {image_path.name}: {str(e)}"
+
+    def process_directory(self, num_workers: int = 4):
+        """
+        Process all images in the input directory
+        
+        Args:
+            num_workers (int): Number of worker processes to use
+        """
+        # Get list of all images
+        image_files = [
+            f for f in self.input_dir.iterdir() 
+            if f.is_file() and f.suffix.lower() in self.supported_formats
+        ]
+        
+        if not image_files:
+            logging.warning("No supported image files found in input directory")
+            return
+
+        logging.info(f"Found {len(image_files)} images to process")
+        
+        # Process images using multiple workers
+        with ProcessPoolExecutor(max_workers=num_workers) as executor:
+            with tqdm(total=len(image_files), desc="Processing images") as pbar:
+                futures = []
+                for image_path in image_files:
+                    future = executor.submit(self.process_image, image_path)
+                    future.add_done_callback(lambda p: pbar.update(1))
+                    futures.append(future)
+                
+                # Process results
+                for future in futures:
+                    success, message = future.result()
+                    if not success:
+                        logging.error(message)
+
+def main():
+    # Update paths to use project-relative directories
+    current_dir = Path(__file__).parent  # Get the directory where this script is located
+    input_dir = current_dir / "data" / "training_images"
+    output_dir = current_dir / "data" / "training_images_processed"
+    
+    processor = ImagePreProcessor(
+        input_dir=input_dir,
+        output_dir=output_dir,
+        target_size=(512, 512),  # Good size for Kohya training
+        padding=0.3,             # 30% padding around faces
+    )
+    
+    processor.process_directory(num_workers=4)
+
+if __name__ == "__main__":
+    main()

isa_model/training/image_model/train/train.py

@@ -0,0 +1,42 @@
+import json
+import subprocess
+from pathlib import Path
+
+def train_lora():
+    # Load your config
+    with open('training_config.json', 'r') as f:
+        config = json.load(f)
+    
+    # Construct the training command
+    cmd = [
+        "accelerate", "launch",
+        "--num_cpu_threads_per_process", str(config["num_cpu_threads_per_process"]),
+        "train_network.py",
+        "--pretrained_model_name_or_path", config["pretrained_model_name_or_path"],
+        "--train_data_dir", config["train_data_dir"],
+        "--output_dir", config["output_dir"],
+        "--output_name", config["output_name"],
+        "--save_model_as", config["save_model_as"],
+        "--learning_rate", str(config["learning_rate"]),
+        "--train_batch_size", str(config["train_batch_size"]),
+        "--epoch", str(config["epoch"]),
+        "--save_every_n_epochs", str(config["save_every_n_epochs"]),
+        "--mixed_precision", config["mixed_precision"],
+        "--cache_latents",
+        "--gradient_checkpointing"
+    ]
+
+    # Add FLUX specific parameters
+    if config.get("flux1_checkbox"):
+        cmd.extend([
+            "--flux1_t5xxl", config["flux1_t5xxl"],
+            "--flux1_clip_l", config["flux1_clip_l"],
+            "--flux1_cache_text_encoder_outputs",
+            "--flux1_cache_text_encoder_outputs_to_disk"
+        ])
+
+    # Execute the training
+    subprocess.run(cmd, check=True)
+
+if __name__ == "__main__":
+    train_lora() 

isa_model/training/image_model/train/train_flux.py

@@ -0,0 +1,41 @@
+import json
+import subprocess
+from pathlib import Path
+
+def train_flux():
+    # Load your config
+    with open('flux_config.json', 'r') as f:
+        config = json.load(f)
+    
+    # Construct the training command for Flux finetuning
+    cmd = [
+        "accelerate", "launch",
+        "--num_cpu_threads_per_process", str(config["num_cpu_threads_per_process"]),
+        "train_db.py",
+        "--pretrained_model_name_or_path", config["pretrained_model_name_or_path"],
+        "--train_data_dir", config["train_data_dir"],
+        "--output_dir", config["output_dir"],
+        "--output_name", config["output_name"],
+        "--train_batch_size", str(config["train_batch_size"]),
+        "--save_every_n_epochs", str(config["save_every_n_epochs"]),
+        "--learning_rate", str(config["learning_rate"]),
+        "--max_train_epochs", str(config["epoch"]),
+        "--mixed_precision", config["mixed_precision"],
+        "--save_model_as", config["save_model_as"],
+        "--cache_latents",
+        "--cache_latents_to_disk",
+        "--gradient_checkpointing",
+        "--optimizer_type", "Adafactor",
+        "--optimizer_args", "scale_parameter=False relative_step=False warmup_init=False weight_decay=0.01",
+        "--max_resolution", "1024,1024",
+        "--full_bf16",
+        "--flux1_checkbox",
+        "--flux1_t5xxl", config["flux1_t5xxl"],
+        "--flux1_clip_l", config["flux1_clip_l"],
+        "--flux1_cache_text_encoder_outputs",
+        "--flux1_cache_text_encoder_outputs_to_disk",
+        "--flux_fused_backward_pass"
+    ]
+
+    # Execute the training
+    subprocess.run(cmd, check=True) 

isa_model/training/image_model/train/train_lora.py

@@ -0,0 +1,57 @@
+import json
+import subprocess
+from pathlib import Path
+
+def train_lora():
+    # Load your config
+    with open('training_config.json', 'r') as f:
+        config = json.load(f)
+    
+    # Construct the training command for LoRA
+    cmd = [
+        "accelerate", "launch",
+        "--num_cpu_threads_per_process", str(config["num_cpu_threads_per_process"]),
+        "sdxl_train_network.py",  # Use the SDXL LoRA training script
+        "--network_module", "networks.lora",  # Specify LoRA network
+        "--pretrained_model_name_or_path", config["pretrained_model_name_or_path"],
+        "--train_data_dir", config["train_data_dir"],
+        "--output_dir", config["output_dir"],
+        "--output_name", config["output_name"],
+        "--save_model_as", config["save_model_as"],
+        "--network_alpha", "1",  # LoRA alpha parameter
+        "--network_dim", "32",   # LoRA dimension
+        "--learning_rate", str(config["learning_rate"]),
+        "--train_batch_size", str(config["train_batch_size"]),
+        "--max_train_epochs", str(config["epoch"]),
+        "--save_every_n_epochs", str(config["save_every_n_epochs"]),
+        "--mixed_precision", config["mixed_precision"],
+        "--cache_latents",
+        "--gradient_checkpointing",
+        "--network_args", "conv_dim=32", "conv_alpha=1",  # LoRA network arguments
+        "--noise_offset", "0.1",
+        "--adaptive_noise_scale", "0.01",
+        "--max_resolution", "1024,1024",
+        "--min_bucket_reso", "256",
+        "--max_bucket_reso", "1024",
+        "--xformers",
+        "--bucket_reso_steps", "64",
+        "--caption_extension", ".txt",
+        "--optimizer_type", "AdaFactor",
+        "--optimizer_args", "scale_parameter=False", "relative_step=False", "warmup_init=False",
+        "--lr_scheduler", "constant"
+    ]
+
+    # Add FLUX specific parameters for LoRA
+    if config.get("flux1_checkbox"):
+        cmd.extend([
+            "--flux1_t5xxl", config["flux1_t5xxl"],
+            "--flux1_clip_l", config["flux1_clip_l"],
+            "--flux1_cache_text_encoder_outputs",
+            "--flux1_cache_text_encoder_outputs_to_disk"
+        ])
+
+    # Execute the training
+    subprocess.run(cmd, check=True)
+
+if __name__ == "__main__":
+    train_lora() 

isa_model/training/image_model/train_main.py

@@ -0,0 +1,25 @@
+import os
+from pathlib import Path
+import shutil
+from app.services.training.image_model.raw_data.create_lora_captions import create_lora_captions
+from app.services.training.image_model.train.train_flux import train_flux
+
+def main():
+    # Setup paths
+    project_root = Path(__file__).parent
+    processed_images_dir = project_root / "raw_data/training_images_processed"
+    
+    # 1. Generate captions for all processed images
+    print("Creating captions for processed images...")
+    create_lora_captions(processed_images_dir)
+    
+    # 2. Create Flux config
+    print("Creating Flux configuration...")
+    os.system(f"python {project_root}/configs/create_flux_config.py")
+    
+    # 3. Run Flux training
+    print("Starting Flux training...")
+    train_flux()
+
+if __name__ == "__main__":
+    main() 

isa_model/training/llm_model/annotation/annotation_schema.py

@@ -0,0 +1,47 @@
+# app/services/llm_model/tracing/annotation/annotation_schema.py
+from enum import Enum
+from pydantic import BaseModel, Field
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+class AnnotationType(str, Enum):
+    ACCURACY = "accuracy"
+    HELPFULNESS = "helpfulness"
+    TOXICITY = "toxicity"
+    CUSTOM = "custom"
+
+class RatingScale(int, Enum):
+    POOR = 1
+    FAIR = 2
+    GOOD = 3
+    EXCELLENT = 4
+
+class AnnotationAspects(BaseModel):
+    factually_correct: bool = True
+    relevant: bool = True
+    harmful: bool = False
+    biased: bool = False
+    complete: bool = True
+    efficient: bool = True
+
+class BetterResponse(BaseModel):
+    content: str
+    reason: Optional[str]
+    metadata: Optional[Dict[str, Any]] = {}
+
+class AnnotationFeedback(BaseModel):
+    rating: RatingScale
+    category: AnnotationType
+    aspects: AnnotationAspects
+    better_response: Optional[BetterResponse]
+    comment: Optional[str]
+    metadata: Optional[Dict[str, Any]] = {}
+    is_selected_for_training: bool = False  
+
+class ItemAnnotation(BaseModel):
+    item_id: str
+    feedback: Optional[AnnotationFeedback]
+    status: str = "pending"  
+    annotated_at: Optional[datetime]
+    annotator_id: Optional[str]
+    training_status: Optional[str] = None  

isa_model/training/llm_model/annotation/processors/annotation_processor.py

@@ -0,0 +1,126 @@
+from typing import Dict, Any, List
+from datetime import datetime
+from app.config.config_manager import config_manager
+from app.services.training.llm_model.annotation.annotation_schema import AnnotationFeedback, RatingScale, AnnotationAspects
+from bson.objectid import ObjectId
+from app.services.training.llm_model.annotation.storage.dataset_manager import DatasetManager
+
+class AnnotationProcessor:
+    def __init__(self):
+        self.logger = config_manager.get_logger(__name__)
+        self.dataset_manager = DatasetManager()
+        self.batch_size = 1000  # Configure as needed
+    
+    async def process_queue(self) -> None:
+        """Process pending items and create datasets"""
+        db = await config_manager.get_db('mongodb')
+        queue = db['training_queue']
+        
+        # Process SFT items
+        sft_items = await self._get_pending_items("sft")
+        if len(sft_items) >= self.batch_size:
+            await self._create_sft_dataset(sft_items)
+        
+        # Process RLHF items
+        rlhf_items = await self._get_pending_items("rlhf")
+        if len(rlhf_items) >= self.batch_size:
+            await self._create_rlhf_dataset(rlhf_items)
+
+    async def _create_sft_dataset(self, items: List[Dict[str, Any]]):
+        """Create and upload SFT dataset"""
+        dataset = await self.dataset_manager.create_dataset(
+            name=f"sft_dataset_v{datetime.now().strftime('%Y%m%d')}",
+            type="sft",
+            version=datetime.now().strftime("%Y%m%d"),
+            source_annotations=[item["annotation_id"] for item in items]
+        )
+        
+        formatted_data = [
+            await self._process_sft_item(item) 
+            for item in items
+        ]
+        
+        await self.dataset_manager.upload_dataset_file(
+            dataset.id,
+            formatted_data
+        )
+
+    async def _process_sft_item(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """Process item for SFT dataset generation
+        Format follows HF conversation format for SFT training
+        """
+        db = await config_manager.get_db('mongodb')
+        annotations = db['annotations']
+        
+        # Get full annotation context
+        annotation = await annotations.find_one({"_id": ObjectId(item["annotation_id"])})
+        target_item = next(i for i in annotation["items"] if i["item_id"] == item["item_id"])
+        
+        # Format as conversation
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a helpful AI assistant that provides accurate and relevant information."
+            },
+            {
+                "role": "user",
+                "content": target_item["input"]["messages"][0]["content"]
+            },
+            {
+                "role": "assistant", 
+                "content": target_item["output"]["content"]
+            }
+        ]
+
+        return {
+            "messages": messages,
+            "metadata": {
+                "rating": item["feedback"]["rating"],
+                "aspects": item["feedback"]["aspects"],
+                "category": item["feedback"]["category"]
+            }
+        }
+
+    async def _process_rlhf_item(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """Process item for RLHF dataset generation
+        Format follows preference pairs structure for RLHF training
+        """
+        db = await config_manager.get_db('mongodb')
+        annotations = db['annotations']
+        
+        # Get full annotation context
+        annotation = await annotations.find_one({"_id": ObjectId(item["annotation_id"])})
+        target_item = next(i for i in annotation["items"] if i["item_id"] == item["item_id"])
+        
+        # Format as preference pairs
+        return {
+            "prompt": target_item["input"]["messages"][0]["content"],
+            "chosen": item["feedback"]["better_response"]["content"],
+            "rejected": target_item["output"]["content"],
+            "metadata": {
+                "reason": item["feedback"]["better_response"]["reason"],
+                "category": item["feedback"]["category"]
+            }
+        }
+
+    async def get_training_data(
+        self,
+        data_type: str,
+        limit: int = 1000
+    ) -> List[Dict[str, Any]]:
+        """Retrieve formatted training data"""
+        db = await config_manager.get_db('mongodb')
+        training_data = db['training_data']
+        
+        data = await training_data.find(
+            {"type": data_type}
+        ).limit(limit).to_list(length=limit)
+        
+        if data_type == "sft":
+            return [item["data"]["messages"] for item in data]
+        else:  # rlhf
+            return [{
+                "prompt": item["data"]["prompt"],
+                "chosen": item["data"]["chosen"],
+                "rejected": item["data"]["rejected"]
+            } for item in data]

isa_model/training/llm_model/annotation/storage/dataset_manager.py

@@ -0,0 +1,131 @@
+# app/services/llm_model/annotation/dataset/dataset_manager.py
+from typing import Dict, Any, List
+from datetime import datetime
+import json
+import io
+from app.config.config_manager import config_manager
+from .dataset_schema import Dataset, DatasetType, DatasetStatus, DatasetFiles, DatasetStats
+from bson import ObjectId
+
+class DatasetManager:
+    def __init__(self):
+        self.logger = config_manager.get_logger(__name__)
+        self.minio_client = None
+        self.bucket_name = "training-datasets"
+
+    async def _ensure_minio_client(self):
+        if not self.minio_client:
+            self.minio_client = await config_manager.get_storage_client()
+
+    async def create_dataset(
+        self, 
+        name: str,
+        type: DatasetType,
+        version: str,
+        source_annotations: List[str]
+    ) -> Dataset:
+        """Create a new dataset record"""
+        db = await config_manager.get_db('mongodb')
+        collection = db['training_datasets']
+        
+        dataset = Dataset(
+            name=name,
+            type=type,
+            version=version,
+            storage_path=f"datasets/{type.value}/{version}",
+            files=DatasetFiles(
+                train="train.jsonl",
+                eval=None,
+                test=None
+            ),
+            stats=DatasetStats(
+                total_examples=0,
+                avg_length=0.0,
+                num_conversations=0,
+                additional_metrics={}
+            ),
+            source_annotations=source_annotations,
+            created_at=datetime.utcnow(),
+            status=DatasetStatus.PENDING,
+            metadata={}
+        )
+        
+        result = await collection.insert_one(dataset.dict(exclude={'id'}))
+        return Dataset(**{**dataset.dict(), '_id': result.inserted_id})
+
+    async def upload_dataset_file(
+        self,
+        dataset_id: str,
+        data: List[Dict[str, Any]],
+        file_type: str = "train"
+    ) -> bool:
+        """Upload dataset to MinIO"""
+        try:
+            await self._ensure_minio_client()
+            db = await config_manager.get_db('mongodb')
+            
+            object_id = ObjectId(dataset_id)
+            dataset = await db['training_datasets'].find_one({"_id": object_id})
+            
+            if not dataset:
+                self.logger.error(f"Dataset not found with id: {dataset_id}")
+                return False
+            
+            # Convert to JSONL
+            buffer = io.StringIO()
+            for item in data:
+                buffer.write(json.dumps(item) + "\n")
+            
+            storage_path = dataset['storage_path'].rstrip('/')
+            file_path = f"{storage_path}/{file_type}.jsonl"
+            
+            buffer_value = buffer.getvalue().encode()
+            
+            self.logger.debug(f"Uploading to MinIO path: {file_path}")
+            
+            self.minio_client.put_object(
+                self.bucket_name,
+                file_path,
+                io.BytesIO(buffer_value),
+                len(buffer_value)
+            )
+            
+            avg_length = sum(len(str(item)) for item in data) / len(data) if data else 0
+            
+            await db['training_datasets'].update_one(
+                {"_id": object_id},
+                {
+                    "$set": {
+                        f"files.{file_type}": f"{file_type}.jsonl",
+                        "stats.total_examples": len(data),
+                        "stats.avg_length": avg_length,
+                        "stats.num_conversations": len(data),
+                        "status": DatasetStatus.READY
+                    }
+                }
+            )
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to upload dataset: {e}")
+            return False
+
+    async def get_dataset_info(self, dataset_id: str) -> Dict[str, Any]:
+        """Get dataset information"""
+        try:
+            db = await config_manager.get_db('mongodb')
+            object_id = ObjectId(dataset_id)  # Convert string ID to ObjectId
+            dataset = await db['training_datasets'].find_one({"_id": object_id})
+            
+            if not dataset:
+                self.logger.error(f"Dataset not found with id: {dataset_id}")
+                return None
+            
+            # Convert ObjectId to string for JSON serialization
+            dataset['_id'] = str(dataset['_id'])
+            return dataset
+            
+        except Exception as e:
+            self.logger.error(f"Failed to get dataset info: {e}")
+            return None