devsper 2.1.6__py3-none-any.whl

devsper/tools/data_science/dataset_outlier_detector.py

@@ -0,0 +1,65 @@
+"""Detect outliers using IQR or z-score (simple heuristic)."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+class DatasetOutlierDetectorTool(Tool):
+    """
+    Detect outliers in a numeric array using IQR (Q1 - 1.5*IQR, Q3 + 1.5*IQR) or z-score.
+    """
+
+    name = "dataset_outlier_detector"
+    description = "Detect outliers in numeric data using IQR or z-score method."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "values": {
+                "type": "array",
+                "items": {"type": "number"},
+                "description": "Numeric array",
+            },
+            "method": {"type": "string", "description": "iqr or zscore (default iqr)"},
+            "z_threshold": {"type": "number", "description": "Z-score threshold (default 3.0)"},
+        },
+        "required": ["values"],
+    }
+
+    def run(self, **kwargs) -> str:
+        values = kwargs.get("values")
+        method = kwargs.get("method", "iqr")
+        z_threshold = kwargs.get("z_threshold", 3.0)
+        if not values or not isinstance(values, list):
+            return "Error: values must be a non-empty list of numbers"
+        if np is None:
+            return "Error: numpy is required for this tool"
+        try:
+            arr = np.array(values, dtype=float)
+            arr = arr[~np.isnan(arr)]
+        except (ValueError, TypeError):
+            return "Error: all values must be numeric"
+        if len(arr) < 4:
+            return "Error: need at least 4 values"
+        if method == "zscore":
+            mean, std = np.mean(arr), np.std(arr)
+            if std == 0:
+                return "No variance; no outliers."
+            z = np.abs((arr - mean) / std)
+            outliers = arr[z > z_threshold]
+        else:
+            q1, q3 = np.percentile(arr, 25), np.percentile(arr, 75)
+            iqr = q3 - q1
+            if iqr == 0:
+                return "IQR is 0; no outliers."
+            low, high = q1 - 1.5 * iqr, q3 + 1.5 * iqr
+            outliers = arr[(arr < low) | (arr > high)]
+        count = len(outliers)
+        return f"Outliers: {count} ({100*count/len(arr):.1f}%). Sample (first 10): {outliers[:10].tolist()}"
+
+
+register(DatasetOutlierDetectorTool())

devsper/tools/data_science/dataset_profile.py

@@ -0,0 +1,76 @@
+"""Generate a dataset profile: shape, dtypes, nulls, and basic stats. Uses CSV or numpy array description."""
+
+import csv
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+class DatasetProfileTool(Tool):
+    """
+    Profile a dataset from CSV or from a list of column arrays: shape, nulls, basic stats.
+    """
+
+    name = "dataset_profile"
+    description = "Profile a dataset (CSV path or column lists): shape, nulls, basic stats."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Path to CSV file"},
+            "sample_rows": {"type": "integer", "description": "Max rows to sample for CSV (default 10000)"},
+        },
+        "required": ["path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        path = kwargs.get("path")
+        sample_rows = kwargs.get("sample_rows", 10000)
+        if not path or not isinstance(path, str):
+            return "Error: path must be a non-empty string"
+        if not isinstance(sample_rows, int) or sample_rows < 1:
+            sample_rows = 10000
+        p = Path(path).resolve()
+        if not p.exists() or not p.is_file():
+            return f"Error: file not found: {path}"
+        try:
+            with p.open(encoding="utf-8", errors="replace", newline="") as f:
+                reader = csv.reader(f)
+                rows = list(reader)
+            if not rows:
+                return "Empty CSV."
+            header = rows[0]
+            data = rows[1:][:sample_rows]
+            n_rows, n_cols = len(data), len(header)
+            null_counts = []
+            for j in range(n_cols):
+                col = [row[j] if j < len(row) else "" for row in data]
+                nulls = sum(1 for c in col if c.strip() == "" or c.lower() in ("na", "nan", "none", "null"))
+                null_counts.append(nulls)
+            lines = [
+                "Dataset profile",
+                "=" * 40,
+                f"Shape: {n_rows} rows, {n_cols} columns",
+                f"Columns: {', '.join(header[:15])}" + ("..." if n_cols > 15 else ""),
+                "Null-like counts per column:",
+            ]
+            for i, (h, nc) in enumerate(zip(header[:20], null_counts[:20])):
+                lines.append(f"  {h}: {nc}")
+            if np is not None and data:
+                try:
+                    arr = np.array(data, dtype=float, order="C")
+                    mask = np.isnan(arr)
+                    lines.append(f"\nNumeric stats (if applicable): min={np.nanmin(arr):.4f}, max={np.nanmax(arr):.4f}")
+                except (ValueError, TypeError):
+                    pass
+            return "\n".join(lines)
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(DatasetProfileTool())

devsper/tools/data_science/distributed_dataset_processor.py

@@ -0,0 +1,54 @@
+"""Split a dataset (row indices or file) into batches for distributed/swarm processing."""
+
+import json
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class DistributedDatasetProcessorTool(Tool):
+    """
+    Split dataset processing into batches: given total rows or a CSV path, return batch ranges.
+    """
+
+    name = "distributed_dataset_processor"
+    description = "Split dataset into batches for distributed processing. Returns batch plan."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Path to CSV (to count rows) or use total_rows"},
+            "total_rows": {"type": "integer", "description": "Total rows if known"},
+            "batch_size": {"type": "integer", "description": "Rows per batch (default 1000)"},
+        },
+        "required": [],
+    }
+
+    def run(self, **kwargs) -> str:
+        path = kwargs.get("path")
+        total_rows = kwargs.get("total_rows")
+        batch_size = kwargs.get("batch_size", 1000)
+        if not isinstance(batch_size, int) or batch_size < 1:
+            batch_size = 1000
+        if total_rows is not None and isinstance(total_rows, int) and total_rows > 0:
+            n = total_rows
+        elif path and isinstance(path, str):
+            p = Path(path).resolve()
+            if not p.exists() or not p.is_file():
+                return f"Error: file not found: {path}"
+            try:
+                n = sum(1 for _ in p.open(encoding="utf-8", errors="replace")) - 1
+                n = max(0, n)
+            except Exception as e:
+                return f"Error: {e}"
+        else:
+            return "Error: provide path (to CSV) or total_rows"
+        batches = []
+        for start in range(0, n, batch_size):
+            end = min(start + batch_size, n)
+            batches.append({"start": start, "end": end, "size": end - start})
+        result = {"total_rows": n, "batch_size": batch_size, "num_batches": len(batches), "batches": batches}
+        return json.dumps(result, indent=2)
+
+
+register(DistributedDatasetProcessorTool())

devsper/tools/data_science/feature_engineering_suggestions.py

@@ -0,0 +1,69 @@
+"""Suggest simple feature engineering: log, sqrt, squared, binning for numeric columns."""
+
+import csv
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+class FeatureEngineeringSuggestionsTool(Tool):
+    """
+    Suggest feature engineering based on column stats: log (if positive), sqrt, squared, binning.
+    """
+
+    name = "feature_engineering_suggestions"
+    description = "Suggest feature engineering: log, sqrt, squared, binning for numeric columns."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Path to CSV"},
+            "max_columns": {"type": "integer", "description": "Max columns (default 15)"},
+        },
+        "required": ["path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        path = kwargs.get("path")
+        max_columns = kwargs.get("max_columns", 15)
+        if not path or not isinstance(path, str):
+            return "Error: path must be a non-empty string"
+        if np is None:
+            return "Error: numpy is required for this tool"
+        p = Path(path).resolve()
+        if not p.exists() or not p.is_file():
+            return f"Error: file not found: {path}"
+        try:
+            with p.open(encoding="utf-8", errors="replace", newline="") as f:
+                reader = csv.DictReader(f)
+                rows = list(reader)
+            if not rows:
+                return "Empty CSV."
+            lines = ["Feature engineering suggestions", "=" * 40]
+            for col in list(rows[0].keys())[:max_columns]:
+                try:
+                    arr = np.array([float(row.get(col, np.nan)) for row in rows], dtype=float)
+                    arr = arr[~np.isnan(arr)]
+                    if len(arr) < 3:
+                        continue
+                    min_v, max_v = np.min(arr), np.max(arr)
+                    sugs = []
+                    if min_v > 0:
+                        sugs.append("log1p")
+                    sugs.append("sqrt(abs(x))")
+                    sugs.append("squared")
+                    sugs.append("binned (e.g. quintiles)")
+                    lines.append(f"  {col}: " + ", ".join(sugs))
+                except (ValueError, TypeError):
+                    continue
+            return "\n".join(lines) if len(lines) > 1 else "No numeric columns found."
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(FeatureEngineeringSuggestionsTool())

devsper/tools/data_science/feature_importance_estimator.py

@@ -0,0 +1,82 @@
+"""Estimate feature importance using simple correlation with a target column (no model)."""
+
+import csv
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+class FeatureImportanceEstimatorTool(Tool):
+    """
+    Estimate feature importance as absolute correlation with target (numeric). No model training.
+    """
+
+    name = "feature_importance_estimator"
+    description = "Estimate feature importance via correlation with target column (numeric)."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Path to CSV"},
+            "target_column": {"type": "string", "description": "Name of target column"},
+            "top_n": {"type": "integer", "description": "Top N features (default 15)"},
+        },
+        "required": ["path", "target_column"],
+    }
+
+    def run(self, **kwargs) -> str:
+        path = kwargs.get("path")
+        target_column = kwargs.get("target_column")
+        top_n = kwargs.get("top_n", 15)
+        if not path or not isinstance(path, str):
+            return "Error: path must be a non-empty string"
+        if not target_column or not isinstance(target_column, str):
+            return "Error: target_column must be a non-empty string"
+        if not isinstance(top_n, int) or top_n < 1:
+            top_n = 15
+        if np is None:
+            return "Error: numpy is required for this tool"
+        p = Path(path).resolve()
+        if not p.exists() or not p.is_file():
+            return f"Error: file not found: {path}"
+        try:
+            with p.open(encoding="utf-8", errors="replace", newline="") as f:
+                reader = csv.DictReader(f)
+                rows = list(reader)
+            if not rows:
+                return "Empty CSV."
+            headers = list(rows[0].keys())
+            if target_column not in headers:
+                return f"Error: target column '{target_column}' not in {headers}"
+            try:
+                y = np.array([float(row.get(target_column, np.nan)) for row in rows], dtype=float)
+            except (ValueError, TypeError):
+                return "Error: target column must be numeric"
+            importance = []
+            for col in headers:
+                if col == target_column:
+                    continue
+                try:
+                    x = np.array([float(row.get(col, np.nan)) for row in rows], dtype=float)
+                    mask = ~(np.isnan(x) | np.isnan(y))
+                    if mask.sum() < 3:
+                        continue
+                    c = np.corrcoef(x[mask], y[mask])[0, 1]
+                    importance.append((col, abs(float(c))))
+                except (ValueError, TypeError):
+                    continue
+            importance.sort(key=lambda t: -t[1])
+            lines = ["Feature importance (|correlation| with target)", "=" * 40]
+            for name, val in importance[:top_n]:
+                lines.append(f"  {name}: {val:.4f}")
+            return "\n".join(lines) if lines else "No numeric features to correlate."
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(FeatureImportanceEstimatorTool())

devsper/tools/data_science/model_input_validator.py

@@ -0,0 +1,59 @@
+"""Validate model input: check shapes, nulls, and value ranges for a list of arrays."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+class ModelInputValidatorTool(Tool):
+    """
+    Validate model inputs: check for NaNs, shapes, and optional value range.
+    Accepts a single list of numbers (one array) or a JSON-like structure; validates and reports.
+    """
+
+    name = "model_input_validator"
+    description = "Validate model input array: NaNs, shape, value range."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "values": {
+                "type": "array",
+                "items": {"type": "number"},
+                "description": "Single feature array",
+            },
+            "min_value": {"type": "number", "description": "Expected min (optional)"},
+            "max_value": {"type": "number", "description": "Expected max (optional)"},
+        },
+        "required": ["values"],
+    }
+
+    def run(self, **kwargs) -> str:
+        values = kwargs.get("values")
+        min_value = kwargs.get("min_value")
+        max_value = kwargs.get("max_value")
+        if not values or not isinstance(values, list):
+            return "Error: values must be a non-empty list of numbers"
+        if np is None:
+            return "Error: numpy is required for this tool"
+        try:
+            arr = np.array(values, dtype=float)
+        except (ValueError, TypeError):
+            return "Error: all values must be numeric"
+        issues = []
+        nan_count = int(np.isnan(arr).sum())
+        if nan_count > 0:
+            issues.append(f"NaNs: {nan_count}")
+        if min_value is not None and np.nanmin(arr) < min_value:
+            issues.append(f"Values below min {min_value}")
+        if max_value is not None and np.nanmax(arr) > max_value:
+            issues.append(f"Values above max {max_value}")
+        if not issues:
+            return f"Valid. Shape: {arr.shape}, no NaNs, range [{np.nanmin(arr):.4f}, {np.nanmax(arr):.4f}]"
+        return "Validation issues: " + "; ".join(issues)
+
+
+register(ModelInputValidatorTool())

devsper/tools/data_science/time_series_analyzer.py

@@ -0,0 +1,57 @@
+"""Basic time series analysis: trend (linear slope), simple stats. Assumes numeric column as series."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+class TimeSeriesAnalyzerTool(Tool):
+    """
+    Analyze a time series (numeric list): linear trend slope, mean, std, min, max.
+    """
+
+    name = "time_series_analyzer"
+    description = "Analyze time series: trend slope, mean, std, min, max."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "values": {
+                "type": "array",
+                "items": {"type": "number"},
+                "description": "Time series values (ordered)",
+            },
+        },
+        "required": ["values"],
+    }
+
+    def run(self, **kwargs) -> str:
+        values = kwargs.get("values")
+        if not values or not isinstance(values, list):
+            return "Error: values must be a non-empty list of numbers"
+        if np is None:
+            return "Error: numpy is required for this tool"
+        try:
+            arr = np.array(values, dtype=float)
+            arr = arr[~np.isnan(arr)]
+        except (ValueError, TypeError):
+            return "Error: all values must be numeric"
+        if len(arr) < 2:
+            return "Error: need at least 2 values"
+        x = np.arange(len(arr), dtype=float)
+        slope = np.polyfit(x, arr, 1)[0]
+        lines = [
+            "Time series summary",
+            "=" * 40,
+            f"Length: {len(arr)}",
+            f"Mean: {np.mean(arr):.4f}, Std: {np.std(arr):.4f}",
+            f"Min: {np.min(arr):.4f}, Max: {np.max(arr):.4f}",
+            f"Linear trend slope: {slope:.6f}",
+        ]
+        return "\n".join(lines)
+
+
+register(TimeSeriesAnalyzerTool())

devsper/tools/documents/__init__.py

@@ -0,0 +1,11 @@
+"""Document tools: extract text, images, equations, tables from PDF/DOCX/PPTX/XLSX via docproc; write LaTeX, Word, Markdown with citations."""
+
+from devsper.tools.documents.extract_document_text import ExtractDocumentTextTool
+from devsper.tools.documents.extract_document_images import ExtractDocumentImagesTool
+from devsper.tools.documents.extract_equations import ExtractEquationsTool
+from devsper.tools.documents.extract_tables import ExtractTablesTool
+from devsper.tools.documents.document_to_markdown import DocumentToMarkdownTool
+from devsper.tools.documents.summarize_document import SummarizeDocumentTool
+from devsper.tools.documents.write_latex_document import WriteLaTeXDocumentTool
+from devsper.tools.documents.write_markdown_document import WriteMarkdownDocumentTool
+from devsper.tools.documents.write_word_document import WriteWordDocumentTool

devsper/tools/documents/_docproc.py

@@ -0,0 +1,56 @@
+"""Shared helper for docproc CLI: run docproc and read output. Optional dependency."""
+
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+DOCPROC_EXTENSIONS = {".pdf", ".docx", ".pptx", ".xlsx"}
+
+
+def docproc_available() -> bool:
+    """Return True if docproc CLI is available."""
+    try:
+        subprocess.run(
+            ["docproc", "--help"],
+            capture_output=True,
+            timeout=5,
+        )
+        return True
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return False
+
+
+def run_docproc_to_markdown(file_path: str) -> tuple[str, str | None]:
+    """
+    Run docproc --file <path> -o <tmp>.md and read the markdown.
+    Returns (content, None) on success or ("", error_message) on failure.
+    """
+    path = Path(file_path).resolve()
+    if not path.exists() or not path.is_file():
+        return "", f"File not found: {file_path}"
+    if path.suffix.lower() not in DOCPROC_EXTENSIONS:
+        return "", f"Unsupported format. Use one of: {DOCPROC_EXTENSIONS}"
+    if not docproc_available():
+        return "", "docproc not installed. Install with: pip install docproc"
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".md", delete=False) as f:
+            out_path = f.name
+        try:
+            result = subprocess.run(
+                ["docproc", "--file", str(path), "-o", out_path],
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            if result.returncode != 0:
+                err = result.stderr or result.stdout or "Unknown error"
+                return "", f"docproc failed: {err}"
+            content = Path(out_path).read_text(encoding="utf-8", errors="replace")
+            return content, None
+        finally:
+            Path(out_path).unlink(missing_ok=True)
+    except subprocess.TimeoutExpired:
+        return "", "docproc timed out"
+    except Exception as e:
+        return "", str(e)

devsper/tools/documents/document_to_markdown.py

@@ -0,0 +1,29 @@
+"""Convert document to markdown using docproc."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.tools.documents._docproc import run_docproc_to_markdown
+
+
+class DocumentToMarkdownTool(Tool):
+    """Convert PDF, DOCX, PPTX, or XLSX to markdown via docproc. Returns the markdown content."""
+
+    name = "document_to_markdown"
+    description = "Convert document to markdown. Returns full markdown text."
+    input_schema = {
+        "type": "object",
+        "properties": {"file_path": {"type": "string", "description": "Path to the document"}},
+        "required": ["file_path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        file_path = kwargs.get("file_path")
+        if not file_path or not isinstance(file_path, str):
+            return "Error: file_path must be a non-empty string"
+        content, err = run_docproc_to_markdown(file_path)
+        if err:
+            return err
+        return content.strip() or "(empty markdown)"
+
+
+register(DocumentToMarkdownTool())

devsper/tools/documents/extract_document_images.py

@@ -0,0 +1,39 @@
+"""Extract image references/descriptions from docproc markdown output."""
+
+import re
+from pathlib import Path
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.tools.documents._docproc import run_docproc_to_markdown
+
+
+class ExtractDocumentImagesTool(Tool):
+    """Extract image blocks (markdown image syntax or alt text) from document via docproc."""
+
+    name = "extract_document_images"
+    description = "Extract image references and descriptions from document (docproc markdown)."
+    input_schema = {
+        "type": "object",
+        "properties": {"file_path": {"type": "string", "description": "Path to the document"}},
+        "required": ["file_path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        file_path = kwargs.get("file_path")
+        if not file_path or not isinstance(file_path, str):
+            return "Error: file_path must be a non-empty string"
+        content, err = run_docproc_to_markdown(file_path)
+        if err:
+            return err
+        images = re.findall(r"!\[([^\]]*)\]\(([^)]+)\)", content)
+        if not images:
+            alt_lines = re.findall(r"(?m)^.*[Ii]mage[^:\n]*:\s*.+$", content)
+            if alt_lines:
+                return "Image descriptions:\n" + "\n".join(alt_lines[:20])
+            return "No image blocks found in extracted markdown. Docproc may embed images as text descriptions."
+        lines = [f"alt: {a}\nurl: {u}" for a, u in images[:30]]
+        return "\n---\n".join(lines)
+
+
+register(ExtractDocumentImagesTool())

devsper/tools/documents/extract_document_text.py

@@ -0,0 +1,29 @@
+"""Extract full text from a document (PDF, DOCX, etc.) using docproc."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.tools.documents._docproc import run_docproc_to_markdown
+
+
+class ExtractDocumentTextTool(Tool):
+    """Extract all text from a document (PDF, DOCX, PPTX, XLSX) via docproc."""
+
+    name = "extract_document_text"
+    description = "Extract full text from PDF, DOCX, PPTX, or XLSX using docproc."
+    input_schema = {
+        "type": "object",
+        "properties": {"file_path": {"type": "string", "description": "Path to the document"}},
+        "required": ["file_path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        file_path = kwargs.get("file_path")
+        if not file_path or not isinstance(file_path, str):
+            return "Error: file_path must be a non-empty string"
+        content, err = run_docproc_to_markdown(file_path)
+        if err:
+            return err
+        return content.strip() or "(no text extracted)"
+
+
+register(ExtractDocumentTextTool())

devsper/tools/documents/extract_equations.py

@@ -0,0 +1,36 @@
+"""Extract equation-like content (LaTeX, code blocks) from docproc markdown."""
+
+import re
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+from devsper.tools.documents._docproc import run_docproc_to_markdown
+
+
+class ExtractEquationsTool(Tool):
+    """Extract equations from document: LaTeX ($...$) and math code blocks."""
+
+    name = "extract_equations"
+    description = "Extract equations (LaTeX and math blocks) from document via docproc."
+    input_schema = {
+        "type": "object",
+        "properties": {"file_path": {"type": "string", "description": "Path to the document"}},
+        "required": ["file_path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        file_path = kwargs.get("file_path")
+        if not file_path or not isinstance(file_path, str):
+            return "Error: file_path must be a non-empty string"
+        content, err = run_docproc_to_markdown(file_path)
+        if err:
+            return err
+        inline = re.findall(r"\$([^$]+)\$", content)
+        block = re.findall(r"\$\$([^$]+)\$\$", content)
+        code_blocks = re.findall(r"```(?:\w*)\n(.*?)```", content, re.DOTALL)
+        equations = block + inline + [c.strip() for c in code_blocks if "\\" in c or "=" in c][:10]
+        if not equations:
+            return "No equations found in extracted markdown."
+        return "Equations:\n" + "\n---\n".join(equations[:30])
+
+
+register(ExtractEquationsTool())