vesper-wizard 2.0.5 → 2.0.7

package/src/python/media_engine.py

@@ -0,0 +1,133 @@
+import sys
+import json
+import os
+import cv2
+import numpy as np
+
+# Audio analysis depends on librosa/soundfile. Fallback if not available.
+try:
+    import librosa
+    AUDIO_SUPPORT = True
+except ImportError:
+    AUDIO_SUPPORT = False
+
+def analyze_audio(path):
+    if not AUDIO_SUPPORT:
+        return {"status": "error", "error": "librosa not installed"}
+    
+    try:
+        # Load audio (mono, default sr)
+        y, sr = librosa.load(path, sr=None)
+        duration = librosa.get_duration(y=y, sr=sr)
+        
+        # Audio metrics
+        rms = librosa.feature.rms(y=y)
+        avg_rms = float(np.mean(rms))
+        
+        return {
+            "status": "ok",
+            "type": "audio",
+            "filename": os.path.basename(path),
+            "sample_rate": int(sr),
+            "duration": float(duration),
+            "avg_volume_rms": avg_rms,
+            "is_silent": avg_rms < 0.001
+        }
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def analyze_video(path):
+    try:
+        cap = cv2.VideoCapture(path)
+        if not cap.isOpened():
+            return {"status": "error", "error": "Could not open video file"}
+        
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        duration = frame_count / fps if fps > 0 else 0
+        
+        # Check integrity by reading a few frames
+        test_frame_indices = [0, frame_count // 2, frame_count - 1] if frame_count > 0 else []
+        failed_frames = 0
+        
+        for idx in test_frame_indices:
+            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+            ret, frame = cap.read()
+            if not ret or frame is None:
+                failed_frames += 1
+        
+        cap.release()
+        
+        return {
+            "status": "ok",
+            "type": "video",
+            "filename": os.path.basename(path),
+            "width": width,
+            "height": height,
+            "fps": float(fps),
+            "duration": float(duration),
+            "frame_count": frame_count,
+            "corruption_risk": "high" if failed_frames > 0 else "low"
+        }
+    except Exception as e:
+        return {"status": "error", "error": str(e)}
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "No path provided"}))
+        sys.exit(1)
+
+    input_path = sys.argv[1]
+    results = []
+
+    # Supported extensions
+    AUDIO_EXTS = (".wav", ".mp3", ".flac", ".ogg", ".m4a")
+    VIDEO_EXTS = (".mp4", ".avi", ".mkv", ".mov", ".wmv")
+
+    if os.path.isfile(input_path):
+        ext = os.path.splitext(input_path.lower())[1]
+        if ext in AUDIO_EXTS:
+            results.append(analyze_audio(input_path))
+        elif ext in VIDEO_EXTS:
+            results.append(analyze_video(input_path))
+        else:
+            results.append({"status": "error", "error": f"Unsupported file type: {ext}"})
+    elif os.path.isdir(input_path):
+        files = [os.path.join(input_path, f) for f in os.listdir(input_path)]
+        for f in files[:50]: # Limit for demo
+            ext = os.path.splitext(f.lower())[1]
+            if ext in AUDIO_EXTS:
+                results.append(analyze_audio(f))
+            elif ext in VIDEO_EXTS:
+                results.append(analyze_video(f))
+    else:
+        print(json.dumps({"error": "Invalid path"}))
+        sys.exit(1)
+
+    # Filtering failed results for report aggregation
+    ok_results = [r for r in results if r.get("status") == "ok"]
+    
+    report = {
+        "total_files": len(results),
+        "ok_files": len(ok_results),
+        "failed_files": len(results) - len(ok_results),
+        "details": results
+    }
+    
+    # Calculate some averages if files were found
+    if ok_results:
+        audio_files = [r for r in ok_results if r["type"] == "audio"]
+        video_files = [r for r in ok_results if r["type"] == "video"]
+        
+        if audio_files:
+            report["avg_audio_duration"] = float(np.mean([r["duration"] for r in audio_files]))
+        if video_files:
+            report["avg_video_duration"] = float(np.mean([r["duration"] for r in video_files]))
+            report["avg_fps"] = float(np.mean([r["fps"] for r in video_files]))
+
+    print(json.dumps(report))
+
+if __name__ == "__main__":
+    main()

package/src/python/nasa_adapter.py

@@ -0,0 +1,82 @@
+import sys
+import json
+import argparse
+import urllib.request
+import urllib.parse
+from datetime import datetime
+
+# NASA Data Portal uses Socrata
+NASA_API_URL = "https://api.us.socrata.com/api/catalog/v1"
+NASA_DOMAIN = "data.nasa.gov"
+
+def search_nasa(query: str, limit: int = 10):
+    """
+    Search NASA data portal.
+    """
+    try:
+        params = {
+            "q": query,
+            "limit": limit,
+            "domains": NASA_DOMAIN,
+            "search_context": NASA_DOMAIN
+        }
+        
+        query_string = urllib.parse.urlencode(params)
+        url = f"{NASA_API_URL}?{query_string}"
+        
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req) as response:
+            data = json.load(response)
+        
+        results = []
+        # Socrata catalog results are in 'results'
+        items = data.get('results', [])
+        
+        for item in items:
+            ds = item.get('resource', {})
+            
+            metadata = {
+                "id": f"nasa:{ds.get('id')}", 
+                "source": "nasa",
+                "name": ds.get('name'),
+                "description": ds.get('description') or "No description available.",
+                "downloads": ds.get('download_count', 0),
+                "likes": ds.get('view_count', 0) // 10,
+                "last_updated": ds.get('updatedAt') or datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+                "quality_score": 90,
+                "license": {
+                    "id": "public_domain",
+                    "name": "Public Domain",
+                    "category": "safe",
+                    "usage_restrictions": [],
+                    "warnings": []
+                },
+                "tags": ds.get('tags', []),
+                "total_examples": 0,
+                "is_safe_source": True,
+                "is_structured": True,
+                "metadata_url": f"https://data.nasa.gov/d/{ds.get('id')}",
+                "domain": "science"
+            }
+            
+            results.append(metadata)
+                    
+        return results
+
+    except Exception as e:
+        return {"error": str(e)}
+
+def main():
+    parser = argparse.ArgumentParser(description="NASA Adapter")
+    parser.add_argument("--action", required=True, choices=["search"])
+    parser.add_argument("--query", required=True)
+    parser.add_argument("--limit", type=int, default=10)
+    
+    args = parser.parse_args()
+    
+    if args.action == "search":
+        results = search_nasa(args.query, args.limit)
+        print(json.dumps(results))
+
+if __name__ == "__main__":
+    main()

package/src/python/openml_engine.py

@@ -0,0 +1,146 @@
+import sys
+import json
+import argparse
+import tempfile
+import os
+from typing import Dict, Any, List
+
+try:
+    import openml
+except ImportError:
+    openml = None
+
+def _ensure_openml() -> Dict[str, Any]:
+    if openml is None:
+        return {"ok": False, "error": "openml package is not installed. Run 'pip install openml'"}
+    return {"ok": True}
+
+def _dataset_to_dict(ds: Dict[str, Any]) -> Dict[str, Any]:
+    # OpenML dataset dict from list_datasets
+    did = ds.get("did", "")
+    name = ds.get("name", f"dataset_{did}")
+    version = ds.get("version", "1")
+    status = ds.get("status", "active")
+    format = ds.get("format", "unknown")
+    
+    # Map to Vesper DatasetMetadata format
+    return {
+        "id": f"openml:{did}",
+        "name": name,
+        "source": "openml",
+        "description": f"OpenML Dataset {name} (ID: {did}, Version: {version}, Format: {format}, Status: {status})",
+        "author": "OpenML Community",
+        "license": "Public",
+        "tags": ["openml", format.lower()],
+        "downloads": ds.get("NumberOfDownloads", 0),
+        "likes": ds.get("NumberOfLikes", 0),
+        "created_at": ds.get("upload_date", ""),
+        "updated_at": ds.get("upload_date", ""),
+        "size_bytes": 0, # Not always available in list
+        "quality_score": 0.8, # Default good score for OpenML
+        "domain": "machine_learning",
+        "is_gated": False,
+        "is_nsfw": False,
+        "description_length": 100,
+        "has_readme": False,
+    }
+
+def discover(query: str, limit: int = 20) -> Dict[str, Any]:
+    check = _ensure_openml()
+    if not check.get("ok"):
+        return check
+
+    try:
+        # OpenML list_datasets doesn't have a direct text search in the python API easily exposed without downloading all.
+        # But we can filter by tag or just get a list and filter locally if needed, or use the REST API directly.
+        # Actually, openml.datasets.list_datasets() returns a dict of datasets.
+        # We can fetch a larger batch and filter by name/keyword.
+        
+        # Fetching a batch of datasets
+        datasets = openml.datasets.list_datasets(output_format='dataframe')
+        
+        if query:
+            # Simple case-insensitive search in name
+            mask = datasets['name'].str.contains(query, case=False, na=False)
+            filtered = datasets[mask]
+        else:
+            filtered = datasets
+            
+        # Sort by NumberOfDownloads if available, else just take top
+        if 'NumberOfDownloads' in filtered.columns:
+            filtered = filtered.sort_values('NumberOfDownloads', ascending=False)
+            
+        top_k = filtered.head(limit)
+        
+        # Convert to list of dicts
+        records = top_k.to_dict(orient='records')
+        items = [_dataset_to_dict(r) for r in records]
+        
+        return {"ok": True, "results": items, "count": len(items)}
+    except Exception as e:
+        return {"ok": False, "error": f"OpenML discover failed: {str(e)}"}
+
+def download(dataset_ref: str, target_dir: str) -> Dict[str, Any]:
+    check = _ensure_openml()
+    if not check.get("ok"):
+        return check
+
+    try:
+        # dataset_ref is expected to be "openml:ID"
+        if dataset_ref.startswith("openml:"):
+            did_str = dataset_ref.split(":")[1]
+        else:
+            did_str = dataset_ref
+            
+        did = int(did_str)
+        
+        if not target_dir:
+            target_dir = tempfile.mkdtemp(prefix="vesper_openml_")
+            
+        os.makedirs(target_dir, exist_ok=True)
+        
+        # Get the dataset
+        dataset = openml.datasets.get_dataset(did, download_data=True, download_qualities=False, download_features_meta_data=False)
+        
+        # Get the pandas dataframe
+        X, y, categorical_indicator, attribute_names = dataset.get_data(
+            dataset_format="dataframe"
+        )
+        
+        # If there's a target column (y), we might want to join it back if it was separated
+        # get_data() can return X and y separately if target is specified, but usually X contains everything if target=None
+        # Let's just get everything
+        df, _, _, _ = dataset.get_data(target=None, dataset_format="dataframe")
+        
+        # Save to parquet in the target directory
+        safe_name = "".join([c if c.isalnum() else "_" for c in dataset.name])
+        file_path = os.path.join(target_dir, f"{safe_name}_{did}.parquet")
+        
+        df.to_parquet(file_path, index=False)
+        
+        return {
+            "ok": True, 
+            "local_path": file_path, 
+            "target_dir": target_dir
+        }
+    except Exception as e:
+        return {"ok": False, "error": f"OpenML download failed: {str(e)}"}
+
+def main():
+    parser = argparse.ArgumentParser(description="Vesper OpenML Engine")
+    parser.add_argument("action", choices=["discover", "download"])
+    parser.add_argument("arg1", help="Query for discover, Dataset ID for download")
+    parser.add_argument("arg2", nargs="?", help="Limit for discover, Target Dir for download")
+
+    args = parser.parse_args()
+
+    if args.action == "discover":
+        limit = int(args.arg2) if args.arg2 else 20
+        result = discover(args.arg1, limit)
+        print(json.dumps(result))
+    elif args.action == "download":
+        result = download(args.arg1, args.arg2)
+        print(json.dumps(result))
+
+if __name__ == "__main__":
+    main()

package/src/python/quality_engine.py

@@ -0,0 +1,267 @@
+import sys
+import json
+import polars as pl
+import numpy as np
+
+def analyze_column(df, col_name, dtype):
+    stats = {
+        "name": col_name,
+        "type": str(dtype),
+        "inferred_type": str(dtype), # Default to actual
+        "missing_count": 0,
+        "missing_percentage": 0.0,
+        "unique_count": 0,
+        "is_constant": False,
+        "is_mixed_type": False
+    }
+
+    try:
+        col = df[col_name]
+        null_count = col.null_count()
+        row_count = len(col)
+        
+        stats["missing_count"] = null_count
+        stats["missing_percentage"] = (null_count / row_count) * 100 if row_count > 0 else 0
+        stats["unique_count"] = col.n_unique()
+        stats["is_constant"] = stats["unique_count"] <= 1 and row_count > 0
+
+        # Schema Inference & Validation
+        is_string = dtype == pl.Utf8 or dtype == pl.Object
+        
+        if is_string and row_count > 0:
+            # Try inferring Numeric
+            # Check if majority can be cast to float
+            try:
+                # Use strict=False to turn non-numbers into nulls
+                numeric_cast = col.str.strip_chars().cast(pl.Float64, strict=False)
+                numeric_nulls = numeric_cast.null_count()
+                
+                # If valid numbers are significantly more than original nulls, it might be numeric
+                valid_numbers = row_count - numeric_nulls
+                original_valid = row_count - null_count
+                
+                if valid_numbers > 0 and (valid_numbers / original_valid) > 0.9:
+                    stats["inferred_type"] = "Numeric (Stored as String)"
+                
+                # Mixed type check: If valid numbers exist but plenty of strings too
+                elif valid_numbers > 0 and (valid_numbers / original_valid) < 0.9:
+                    stats["is_mixed_type"] = True
+            except:
+                pass
+
+        # Numeric Analysis
+        if dtype in [pl.Int64, pl.Int32, pl.Float64, pl.Float32] or stats["inferred_type"].startswith("Numeric"):
+            clean_col = col
+            if is_string:
+                 # Cast for analysis if it was inferred
+                 clean_col = col.str.strip_chars().cast(pl.Float64, strict=False)
+            
+            clean_col = clean_col.drop_nulls()
+            
+            if len(clean_col) > 0:
+                stats["distribution"] = {
+                    "min": float(clean_col.min()),
+                    "max": float(clean_col.max()),
+                    "mean": float(clean_col.mean()),
+                    "std": float(clean_col.std()) if len(clean_col) > 1 else 0,
+                    "p25": float(clean_col.quantile(0.25)),
+                    "p50": float(clean_col.median()),
+                    "p75": float(clean_col.quantile(0.75))
+                }
+
+        # Categorical Analysis
+        if dtype == pl.Utf8 or dtype == pl.Categorical:
+            value_counts = col.value_counts(sort=True).head(5)
+            # Handle different polars versions return structure for value_counts
+            try:
+                # Format: struct with name/counts or columns
+                rows = value_counts.rows()
+                top_values = {}
+                for row in rows:
+                    val = str(row[0]) if row[0] is not None else "null"
+                    count = int(row[1])
+                    top_values[val] = count
+                stats["top_values"] = top_values
+            except:
+                pass
+
+    except Exception as e:
+        stats["error"] = str(e)
+
+    return stats
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"error": "No file path provided"}))
+        sys.exit(1)
+
+    file_path = sys.argv[1]
+    
+    try:
+        # Robust file reading with extension detection
+        file_path_lower = file_path.lower()
+        if file_path_lower.endswith(".csv"):
+            df = pl.read_csv(file_path, ignore_errors=True, n_rows=10000)
+        elif file_path_lower.endswith(".tsv"):
+            df = pl.read_csv(file_path, separator="\t", ignore_errors=True, n_rows=10000)
+        elif file_path_lower.endswith(".txt"):
+            sep = ","
+            try:
+                with open(file_path, "r", encoding="utf-8", errors="ignore") as fh:
+                    first_line = fh.readline()
+                    if "\t" in first_line:
+                        sep = "\t"
+            except Exception:
+                sep = ","
+            df = pl.read_csv(file_path, separator=sep, ignore_errors=True, n_rows=10000)
+        elif file_path_lower.endswith(".parquet"):
+            try:
+                # Try scanning first (faster for large files)
+                df = pl.scan_parquet(file_path).limit(10000).collect()
+            except:
+                df = pl.read_parquet(file_path)
+                if len(df) > 10000: df = df.head(10000)
+        elif file_path_lower.endswith(".jsonl") or file_path_lower.endswith(".ndjson"):
+            # Explicit NDJSON
+            df = pl.scan_ndjson(file_path).limit(10000).collect()
+        elif file_path_lower.endswith(".json"):
+            # Ambiguous .json: Try standard JSON first, then NDJSON fallback
+            try:
+                # read_json reads standard JSON array [{}, {}]
+                df = pl.read_json(file_path)
+                if len(df) > 10000: df = df.head(10000)
+            except Exception:
+                try:
+                     # Fallback to NDJSON (common for large datasets mislabeled as .json)
+                     df = pl.scan_ndjson(file_path).limit(10000).collect()
+                except Exception as e:
+                     print(json.dumps({"error": f"Failed to read JSON: {str(e)}"}))
+                     sys.exit(1)
+        else:
+            print(json.dumps({"error": f"Unsupported file extension: {file_path}"}))
+            sys.exit(1)
+
+        row_count = len(df)
+        column_count = len(df.columns)
+        
+        # Duplicate detection (exact)
+        # NOTE: Some Polars versions can panic on is_duplicated() for nested/null rows.
+        # Use a Python fallback that is slower but robust for the 10k sampled rows.
+        duplicate_count = 0
+        try:
+            seen = set()
+            for row in df.to_dicts():
+                row_key = json.dumps(row, sort_keys=True, default=str)
+                if row_key in seen:
+                    duplicate_count += 1
+                else:
+                    seen.add(row_key)
+        except Exception:
+            duplicate_count = 0
+        
+        columns_stats = []
+        text_cols = []
+        for col in df.columns:
+            stats = analyze_column(df, col, df.schema[col])
+            columns_stats.append(stats)
+            # Check for String type (Polars can return 'String' or 'Utf8' depending on version)
+            dtype_str = stats["type"]
+            if ("String" in dtype_str or "Utf8" in dtype_str) and stats["unique_count"] > 1:
+                text_cols.append(col)
+
+        report = {
+            "row_count": row_count,
+            "column_count": column_count,
+            "duplicate_rows": int(duplicate_count),
+            "duplicate_percentage": (duplicate_count / row_count * 100) if row_count > 0 else 0,
+            "columns": columns_stats,
+            "warnings": [],
+            "schema_warnings": [],
+            "overall_score": 100 
+        }
+
+        # Integrity Check 1: Text Duplicates (Fuzzyish Proxy)
+        # If duplicated rows are 0, check if main text content is duplicated
+        if duplicate_count == 0 and len(text_cols) > 0:
+            # Pick longest text column as likely "content"
+            # In real impl, we'd use heuristics. For now, first text col.
+            target_col = text_cols[0]
+            try:
+                text_dupes = df.select(pl.col(target_col)).is_duplicated().sum()
+                if text_dupes > 0:
+                    report["text_duplicates"] = int(text_dupes)
+                    if text_dupes > (row_count * 0.2):
+                        report["warnings"].append(f"High text duplication in '{target_col}' ({text_dupes} rows)")
+            except Exception:
+                # Skip text duplicate warning if backend cannot compute duplicates for this dtype
+                pass
+
+        # Integrity Check 2: Contamination / Leakage (Basic)
+        # (Skipping correlation for now)
+
+        report["class_imbalance_warnings"] = []
+        report["pii_warnings"] = []
+        
+        # PII Patterns (Regex)
+        import re
+        pii_patterns = {
+            "Email": r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
+            "Phone": r'\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}', # Basic US-ish pattern
+            "SSN": r'\d{3}-\d{2}-\d{4}',
+            "IPv4": r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
+        }
+
+        # Bias & PII Analysis
+        for col_name, stats in zip(df.columns, columns_stats):
+            # Class Imbalance
+            if stats["unique_count"] > 1 and stats["unique_count"] < 50:
+                 try:
+                     col = df[col_name]
+                     top_val_count = col.value_counts().sort("count", descending=True).row(0)[1]
+                     total = len(col)
+                     if total > 0:
+                         ratio = top_val_count / total
+                         if ratio > 0.9:
+                             report["class_imbalance_warnings"].append(f"Severe imbalance in '{col_name}': Top class is {(ratio*100):.1f}% of data")
+                 except:
+                     pass
+            
+            # PII Detection (on Text Columns only)
+            if ("String" in stats["type"] or "Utf8" in stats["type"]):
+                try:
+                    # Sample for performance (check first 1000 non-null values)
+                    sample_text = df[col_name].drop_nulls().head(1000).to_list()
+                    # Join a subset to regex against (faster than row-by-row for simple checks)
+                    combined_text = " ".join([str(x) for x in sample_text])
+                    
+                    for pii_type, pattern in pii_patterns.items():
+                        if re.search(pattern, combined_text):
+                            # Ensure we don't flag column names like "email_address" but actual content
+                            # Double check with a strict count if trigger found
+                            matches = len(re.findall(pattern, combined_text))
+                            if matches > 0:
+                                report["pii_warnings"].append(f"Potential {pii_type} detected in column '{col_name}' ({matches} matches in sample)")
+                except:
+                    pass
+
+        # Basic warnings
+        if report["duplicate_percentage"] > 10:
+            report["warnings"].append("High duplication rate (>10%)")
+        if row_count < 50:
+            report["warnings"].append("Dataset is very small (<50 rows)")
+
+        # Schema warnings
+        for col in columns_stats:
+            if "Numeric" in col.get("inferred_type", "") and "Utf8" in col.get("type", ""):
+                 report["schema_warnings"].append(f"Column '{col['name']}' looks Numeric but is stored as String")
+            if col.get("is_mixed_type"):
+                 report["schema_warnings"].append(f"Column '{col['name']}' likely contains mixed types (numbers and strings)")
+
+        print(json.dumps(report))
+
+    except Exception as e:
+        print(json.dumps({"error": f"Analysis failed: {str(e)}"}))
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/src/python/row_count.py

@@ -0,0 +1,54 @@
+import sys
+import json
+import os
+
+try:
+    import polars as pl
+except Exception:
+    print(json.dumps({"ok": False, "error": "polars is required"}))
+    sys.exit(1)
+
+
+def count_rows(path: str) -> int:
+    ext = os.path.splitext(path)[1].lower()
+
+    if ext == ".csv":
+        # Faster than full read for large csv
+        return int(pl.scan_csv(path, ignore_errors=True).select(pl.len()).collect().item())
+    if ext in [".parquet", ".pq"]:
+        return int(pl.scan_parquet(path).select(pl.len()).collect().item())
+    if ext in [".feather", ".ftr", ".arrow", ".ipc"]:
+        return int(pl.scan_ipc(path).select(pl.len()).collect().item())
+    if ext in [".jsonl", ".ndjson"]:
+        return int(pl.scan_ndjson(path).select(pl.len()).collect().item())
+    if ext == ".json":
+        # fallback to eager for plain JSON arrays
+        try:
+            return int(pl.read_json(path).height)
+        except Exception:
+            return int(pl.scan_ndjson(path).select(pl.len()).collect().item())
+
+    # unknown extension fallback
+    return int(pl.read_csv(path, ignore_errors=True).height)
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"ok": False, "error": "Usage: row_count.py <file_path>"}))
+        sys.exit(1)
+
+    p = sys.argv[1]
+    if not os.path.exists(p):
+        print(json.dumps({"ok": False, "error": f"File not found: {p}"}))
+        sys.exit(1)
+
+    try:
+        rows = count_rows(p)
+        print(json.dumps({"ok": True, "rows": rows}))
+    except Exception as e:
+        print(json.dumps({"ok": False, "error": str(e)}))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()