devsper 2.1.6__py3-none-any.whl

devsper/tools/knowledge/citation_graph_builder.py

@@ -0,0 +1,69 @@
+"""Build a citation graph from document text: extract citations and link doc -> refs."""
+
+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
+
+CITE_PATTERNS = [
+    re.compile(r"\([^)]*?\b(?:et\s+al\.?|&\s*[^)]+)[^)]*?\d{4}[^)]*\)", re.I),
+    re.compile(r"\[\d+(?:\s*[-–,]\s*\d+)*\]"),
+    re.compile(r"\([A-Z][a-z]+(?:\s+et\s+al\.?)?,?\s*\d{4}\)"),
+]
+
+
+class CitationGraphBuilderTool(Tool):
+    """
+    Build a simple citation graph from multiple documents: nodes are docs, edges are citation refs.
+    """
+
+    name = "citation_graph_builder"
+    description = "Build a citation graph from documents: extract citations and doc-to-ref links."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_paths": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "List of paths to documents",
+            },
+        },
+        "required": ["file_paths"],
+    }
+
+    def _extract_citations(self, text: str) -> list[str]:
+        refs = []
+        for pat in CITE_PATTERNS:
+            refs.extend(pat.findall(text))
+        return list(dict.fromkeys(refs))
+
+    def run(self, **kwargs) -> str:
+        file_paths = kwargs.get("file_paths")
+        if not file_paths or not isinstance(file_paths, list):
+            return "Error: file_paths must be a non-empty list of strings"
+        nodes = []
+        edges = []
+        for path in file_paths:
+            if not isinstance(path, str) or not path.strip():
+                continue
+            p = Path(path.strip()).resolve()
+            if not p.exists() or not p.is_file():
+                continue
+            content, err = run_docproc_to_markdown(str(p))
+            if err:
+                continue
+            text = content or ""
+            name = p.name
+            nodes.append(name)
+            refs = self._extract_citations(text)
+            for ref in refs:
+                edges.append({"from": name, "citation": ref})
+        result = {"nodes": nodes, "edges": edges, "edge_count": len(edges)}
+        import json
+
+        return json.dumps(result, indent=2)
+
+
+register(CitationGraphBuilderTool())

devsper/tools/knowledge/concept_frequency_analyzer.py

@@ -0,0 +1,74 @@
+"""Analyze concept (word) frequency across multiple documents."""
+
+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
+
+STOP = frozenset(
+    "a an the and or but in on at to for of with by from as is was are were been be have has had do does did will would could should may might must can this that these those it its i we they".split()
+)
+
+
+class ConceptFrequencyAnalyzerTool(Tool):
+    """
+    Compute concept (word) frequency across a corpus and return global and per-doc stats.
+    """
+
+    name = "concept_frequency_analyzer"
+    description = "Analyze concept/word frequency across multiple documents."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_paths": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "List of paths to documents",
+            },
+            "top_n": {"type": "integer", "description": "Top N concepts (default 20)"},
+            "min_word_length": {"type": "integer", "description": "Min concept length (default 4)"},
+        },
+        "required": ["file_paths"],
+    }
+
+    def run(self, **kwargs) -> str:
+        file_paths = kwargs.get("file_paths")
+        top_n = kwargs.get("top_n", 20)
+        min_len = kwargs.get("min_word_length", 4)
+        if not file_paths or not isinstance(file_paths, list):
+            return "Error: file_paths must be a non-empty list of strings"
+        if not isinstance(top_n, int) or top_n < 1:
+            top_n = 20
+        if not isinstance(min_len, int) or min_len < 1:
+            min_len = 4
+        global_counts = {}
+        doc_counts = []
+        for path in file_paths:
+            if not isinstance(path, str) or not path.strip():
+                continue
+            p = Path(path.strip()).resolve()
+            if not p.exists() or not p.is_file():
+                continue
+            content, err = run_docproc_to_markdown(str(p))
+            if err:
+                continue
+            text = (content or "").lower()
+            words = [w for w in re.findall(r"[a-z]+", text) if len(w) >= min_len and w not in STOP]
+            local = {}
+            for w in words:
+                local[w] = local.get(w, 0) + 1
+                global_counts[w] = global_counts.get(w, 0) + 1
+            doc_counts.append({"path": p.name, "concepts": len(local), "total_tokens": len(words)})
+        sorted_global = sorted(global_counts.items(), key=lambda x: -x[1])[:top_n]
+        lines = ["Global top concepts (concept: count):"]
+        for w, c in sorted_global:
+            lines.append(f"  {w}: {c}")
+        lines.append("\nPer-document concept counts:")
+        for d in doc_counts:
+            lines.append(f"  {d['path']}: {d['concepts']} concepts, {d['total_tokens']} tokens")
+        return "\n".join(lines)
+
+
+register(ConceptFrequencyAnalyzerTool())

devsper/tools/knowledge/corpus_builder.py

@@ -0,0 +1,66 @@
+"""Build a text corpus from a list of document paths (PDF, DOCX, etc.) using docproc."""
+
+import json
+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, DOCPROC_EXTENSIONS
+
+
+class CorpusBuilderTool(Tool):
+    """
+    Build a structured corpus from multiple documents.
+    Extracts text via docproc and returns a JSON-like summary with paths and excerpt lengths.
+    """
+
+    name = "corpus_builder"
+    description = "Build a text corpus from multiple document paths (PDF, DOCX, PPTX, XLSX). Uses docproc."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_paths": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "List of paths to documents",
+            },
+            "max_chars_per_doc": {
+                "type": "integer",
+                "description": "Max chars to store per document (default 5000)",
+            },
+        },
+        "required": ["file_paths"],
+    }
+
+    def run(self, **kwargs) -> str:
+        file_paths = kwargs.get("file_paths")
+        max_chars = kwargs.get("max_chars_per_doc", 5000)
+        if not file_paths or not isinstance(file_paths, list):
+            return "Error: file_paths must be a non-empty list of strings"
+        if not isinstance(max_chars, int) or max_chars < 1:
+            max_chars = 5000
+        corpus = []
+        errors = []
+        for path in file_paths:
+            if not isinstance(path, str) or not path.strip():
+                continue
+            p = Path(path.strip()).resolve()
+            if not p.exists() or not p.is_file():
+                errors.append(f"{path}: not found")
+                continue
+            if p.suffix.lower() not in DOCPROC_EXTENSIONS:
+                errors.append(f"{path}: unsupported format")
+                continue
+            content, err = run_docproc_to_markdown(str(p))
+            if err:
+                errors.append(f"{path}: {err}")
+                continue
+            excerpt = (content or "").strip()[:max_chars]
+            corpus.append({"path": str(p), "length": len(content or ""), "excerpt_length": len(excerpt)})
+        result = {"documents": len(corpus), "corpus": corpus}
+        if errors:
+            result["errors"] = errors
+        return json.dumps(result, indent=2)
+
+
+register(CorpusBuilderTool())

devsper/tools/knowledge/cross_document_entity_linker.py

@@ -0,0 +1,71 @@
+"""Link entities (capitalized phrases) across documents by matching exact strings."""
+
+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 CrossDocumentEntityLinkerTool(Tool):
+    """
+    Extract capitalized multi-word phrases as candidate entities and link them across documents.
+    """
+
+    name = "cross_document_entity_linker"
+    description = "Link entities (capitalized phrases) across multiple documents."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_paths": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "List of paths to documents",
+            },
+            "min_phrase_length": {"type": "integer", "description": "Min words in phrase (default 2)"},
+        },
+        "required": ["file_paths"],
+    }
+
+    def _extract_entities(self, text: str, min_words: int) -> set[str]:
+        pat = re.compile(r"\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b")
+        phrases = set()
+        for m in pat.finditer(text):
+            phrase = m.group(1).strip()
+            if len(phrase.split()) >= min_words:
+                phrases.add(phrase)
+        return phrases
+
+    def run(self, **kwargs) -> str:
+        file_paths = kwargs.get("file_paths")
+        min_words = kwargs.get("min_phrase_length", 2)
+        if not file_paths or not isinstance(file_paths, list):
+            return "Error: file_paths must be a non-empty list of strings"
+        if not isinstance(min_words, int) or min_words < 1:
+            min_words = 2
+        doc_entities = {}
+        all_entities = set()
+        for path in file_paths:
+            if not isinstance(path, str) or not path.strip():
+                continue
+            p = Path(path.strip()).resolve()
+            if not p.exists() or not p.is_file():
+                continue
+            content, err = run_docproc_to_markdown(str(p))
+            if err:
+                continue
+            entities = self._extract_entities(content or "", min_words)
+            doc_entities[p.name] = list(entities)
+            all_entities |= entities
+        cross = {e: [name for name, ents in doc_entities.items() if e in ents] for e in all_entities}
+        cross = {k: v for k, v in cross.items() if len(v) > 1}
+        import json
+
+        return json.dumps(
+            {"documents": list(doc_entities.keys()), "cross_document_entities": cross, "per_doc": doc_entities},
+            indent=2,
+        )
+
+
+register(CrossDocumentEntityLinkerTool())

devsper/tools/knowledge/document_corpus_summary.py

@@ -0,0 +1,68 @@
+"""Summarize a document corpus: total size, doc counts, and aggregate stats."""
+
+import json
+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, DOCPROC_EXTENSIONS
+
+
+class DocumentCorpusSummaryTool(Tool):
+    """
+    Produce an aggregate summary of a corpus: number of docs, total chars, by-extension counts.
+    """
+
+    name = "document_corpus_summary"
+    description = "Summarize a document corpus: doc count, total size, and stats per format."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_paths": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "List of paths to documents",
+            },
+            "directory": {"type": "string", "description": "Alternatively, directory to scan for docs"},
+        },
+    }
+
+    def run(self, **kwargs) -> str:
+        file_paths = kwargs.get("file_paths")
+        directory = kwargs.get("directory")
+        paths = []
+        if file_paths and isinstance(file_paths, list):
+            paths = [p for p in file_paths if isinstance(p, str) and p.strip()]
+        if directory and isinstance(directory, str):
+            d = Path(directory).resolve()
+            if d.exists() and d.is_dir():
+                for ext in DOCPROC_EXTENSIONS:
+                    paths.extend(str(p) for p in d.rglob(f"*{ext}"))
+        if not paths:
+            return "Error: provide file_paths (list) or directory (path to folder)"
+        by_ext = {}
+        total_chars = 0
+        success = 0
+        for path in paths:
+            p = Path(path).resolve()
+            if not p.exists() or not p.is_file():
+                continue
+            ext = p.suffix.lower()
+            if ext not in DOCPROC_EXTENSIONS:
+                continue
+            by_ext[ext] = by_ext.get(ext, 0) + 1
+            content, err = run_docproc_to_markdown(str(p))
+            if err:
+                continue
+            success += 1
+            total_chars += len(content or "")
+        summary = {
+            "total_documents": len(paths),
+            "successfully_processed": success,
+            "total_characters": total_chars,
+            "by_extension": by_ext,
+        }
+        return json.dumps(summary, indent=2)
+
+
+register(DocumentCorpusSummaryTool())

devsper/tools/knowledge/document_topic_extractor.py

@@ -0,0 +1,58 @@
+"""Extract topic-like keywords from document text using frequency and stopword filtering."""
+
+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
+
+STOP = frozenset(
+    "a an the and or but in on at to for of with by from as is was are were been be have has had do does did will would could should may might must can this that these those it its".split()
+)
+
+
+class DocumentTopicExtractorTool(Tool):
+    """
+    Extract candidate topics/keywords from a document using word frequency and stopword filtering.
+    """
+
+    name = "document_topic_extractor"
+    description = "Extract topic keywords from a document (PDF, DOCX, etc.) via word frequency."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_path": {"type": "string", "description": "Path to the document"},
+            "top_n": {"type": "integer", "description": "Number of top topics (default 15)"},
+            "min_length": {"type": "integer", "description": "Min word length (default 3)"},
+        },
+        "required": ["file_path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        file_path = kwargs.get("file_path")
+        top_n = kwargs.get("top_n", 15)
+        min_length = kwargs.get("min_length", 3)
+        if not file_path or not isinstance(file_path, str):
+            return "Error: file_path must be a non-empty string"
+        if not isinstance(top_n, int) or top_n < 1:
+            top_n = 15
+        if not isinstance(min_length, int) or min_length < 1:
+            min_length = 3
+        content, err = run_docproc_to_markdown(file_path)
+        if err:
+            return err
+        text = (content or "").lower()
+        words = re.findall(r"[a-z]+", text)
+        counts = {}
+        for w in words:
+            if len(w) >= min_length and w not in STOP:
+                counts[w] = counts.get(w, 0) + 1
+        sorted_items = sorted(counts.items(), key=lambda x: -x[1])[:top_n]
+        if not sorted_items:
+            return "No topics extracted (empty or no matching words)."
+        lines = [f"{word}: {count}" for word, count in sorted_items]
+        return "Top topics (word: count):\n" + "\n".join(lines)
+
+
+register(DocumentTopicExtractorTool())

devsper/tools/knowledge/knowledge_graph_extractor.py

@@ -0,0 +1,58 @@
+"""Extract simple subject-relation-object triples from text using heuristic patterns."""
+
+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
+
+RELATION_PATTERN = re.compile(
+    r"(\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\s+(?:is|are|was|were|has|have|uses|used|includes|contain)\s+([^.!?]+?)(?:\.|$)",
+    re.I,
+)
+
+
+class KnowledgeGraphExtractorTool(Tool):
+    """
+    Extract subject-relation-object style triples from document text (heuristic, no NER).
+    """
+
+    name = "knowledge_graph_extractor"
+    description = "Extract subject-relation-object triples from a document for knowledge graph building."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_path": {"type": "string", "description": "Path to the document"},
+            "max_triples": {"type": "integer", "description": "Max triples to return (default 50)"},
+        },
+        "required": ["file_path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        file_path = kwargs.get("file_path")
+        max_triples = kwargs.get("max_triples", 50)
+        if not file_path or not isinstance(file_path, str):
+            return "Error: file_path must be a non-empty string"
+        if not isinstance(max_triples, int) or max_triples < 1:
+            max_triples = 50
+        content, err = run_docproc_to_markdown(file_path)
+        if err:
+            return err
+        text = content or ""
+        triples = []
+        for m in RELATION_PATTERN.finditer(text):
+            subj = m.group(1).strip()
+            obj = m.group(2).strip()[:80]
+            if len(subj) > 2 and len(obj) > 2:
+                triples.append({"subject": subj, "object": obj})
+                if len(triples) >= max_triples:
+                    break
+        if not triples:
+            return "No triples extracted (try a document with 'X is Y' / 'X has Y' style sentences)."
+        import json
+
+        return json.dumps({"triples": triples}, indent=2)
+
+
+register(KnowledgeGraphExtractorTool())

devsper/tools/knowledge/timeline_extractor.py

@@ -0,0 +1,59 @@
+"""Extract date/time mentions from document text to build a simple timeline."""
+
+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
+
+YEAR_PAT = re.compile(r"\b(19\d{2}|20\d{2})\b")
+MONTHS = "january february march april may june july august september october november december".split()
+MONTH_PAT = re.compile(r"\b(" + "|".join(MONTHS) + r")\s*,?\s*(19\d{2}|20\d{2})?", re.I)
+
+
+class TimelineExtractorTool(Tool):
+    """
+    Extract date and year mentions from a document to produce a simple timeline.
+    """
+
+    name = "timeline_extractor"
+    description = "Extract dates and years from a document to build a timeline."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "file_path": {"type": "string", "description": "Path to the document"},
+            "max_entries": {"type": "integer", "description": "Max timeline entries (default 30)"},
+        },
+        "required": ["file_path"],
+    }
+
+    def run(self, **kwargs) -> str:
+        file_path = kwargs.get("file_path")
+        max_entries = kwargs.get("max_entries", 30)
+        if not file_path or not isinstance(file_path, str):
+            return "Error: file_path must be a non-empty string"
+        if not isinstance(max_entries, int) or max_entries < 1:
+            max_entries = 30
+        content, err = run_docproc_to_markdown(file_path)
+        if err:
+            return err
+        text = content or ""
+        years = list(dict.fromkeys(YEAR_PAT.findall(text)))
+        month_matches = list(dict.fromkeys(MONTH_PAT.findall(text)))
+        timeline = []
+        for y in sorted(years, key=int):
+            timeline.append({"type": "year", "value": y})
+        for m in month_matches:
+            month = m[0].lower()
+            year = m[1] if len(m) > 1 and m[1] else None
+            timeline.append({"type": "month", "value": f"{month} {year or ''}".strip()})
+        timeline = timeline[:max_entries]
+        if not timeline:
+            return "No dates or years found in the document."
+        import json
+
+        return json.dumps({"timeline": timeline}, indent=2)
+
+
+register(TimelineExtractorTool())

devsper/tools/math/__init__.py

@@ -0,0 +1,12 @@
+"""Math and analysis tools: expressions, stats, regression, distributions, etc."""
+
+from devsper.tools.math.calculate_expression import CalculateExpressionTool
+from devsper.tools.math.matrix_multiply import MatrixMultiplyTool
+from devsper.tools.math.linear_regression import LinearRegressionTool
+from devsper.tools.math.mean_std import MeanStdTool
+from devsper.tools.math.correlation import CorrelationTool
+from devsper.tools.math.polynomial_fit import PolynomialFitTool
+from devsper.tools.math.histogram import HistogramTool
+from devsper.tools.math.monte_carlo_simulation import MonteCarloSimulationTool
+from devsper.tools.math.random_sample import RandomSampleTool
+from devsper.tools.math.distribution_summary import DistributionSummaryTool

devsper/tools/math/calculate_expression.py

@@ -0,0 +1,52 @@
+"""Safely evaluate a mathematical expression (numbers and basic ops only)."""
+
+import ast
+import operator
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class CalculateExpressionTool(Tool):
+    """Evaluate a safe math expression: numbers, +, -, *, /, **, parentheses. No names."""
+
+    name = "calculate_expression"
+    description = "Evaluate a mathematical expression. Only numbers and +, -, *, /, ** allowed."
+    input_schema = {
+        "type": "object",
+        "properties": {"expression": {"type": "string", "description": "Math expression, e.g. 2 + 3 * 4"}},
+        "required": ["expression"],
+    }
+
+    def run(self, **kwargs) -> str:
+        expression = kwargs.get("expression")
+        if not expression or not isinstance(expression, str):
+            return "Error: expression must be a non-empty string"
+        try:
+            tree = ast.parse(expression, mode="eval")
+            ops = {
+                ast.Add: operator.add,
+                ast.Sub: operator.sub,
+                ast.Mult: operator.mul,
+                ast.Div: operator.truediv,
+                ast.Pow: operator.pow,
+                ast.USub: operator.neg,
+            }
+
+            def eval_node(node):
+                if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
+                    return node.value
+                if isinstance(node, ast.BinOp):
+                    left = eval_node(node.left)
+                    right = eval_node(node.right)
+                    return ops[type(node.op)](left, right)
+                if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
+                    return -eval_node(node.operand)
+                raise ValueError("Only numbers and +, -, *, /, ** allowed")
+            result = eval_node(tree.body)
+            return str(result)
+        except (ValueError, SyntaxError, TypeError) as e:
+            return f"Error: {e}"
+
+
+register(CalculateExpressionTool())

devsper/tools/math/correlation.py

@@ -0,0 +1,44 @@
+"""Compute Pearson correlation between two lists of numbers."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class CorrelationTool(Tool):
+    """Compute Pearson correlation coefficient between x and y."""
+
+    name = "correlation"
+    description = "Compute Pearson correlation between two lists of numbers."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "x": {"type": "array", "description": "First list of numbers"},
+            "y": {"type": "array", "description": "Second list of numbers"},
+        },
+        "required": ["x", "y"],
+    }
+
+    def run(self, **kwargs) -> str:
+        x = kwargs.get("x")
+        y = kwargs.get("y")
+        if not isinstance(x, list) or not isinstance(y, list):
+            return "Error: x and y must be arrays"
+        if len(x) != len(y) or len(x) < 2:
+            return "Error: x and y must have same length >= 2"
+        try:
+            X = [float(v) for v in x]
+            Y = [float(v) for v in y]
+        except (TypeError, ValueError):
+            return "Error: all elements must be numbers"
+        n = len(X)
+        mx = sum(X) / n
+        my = sum(Y) / n
+        sx = (sum((a - mx) ** 2 for a in X) / n) ** 0.5
+        sy = (sum((b - my) ** 2 for b in Y) / n) ** 0.5
+        if sx == 0 or sy == 0:
+            return "Error: zero variance in x or y"
+        r = sum((X[i] - mx) * (Y[i] - my) for i in range(n)) / (n * sx * sy)
+        return f"Pearson r = {r}"
+
+
+register(CorrelationTool())

devsper/tools/math/distribution_summary.py

@@ -0,0 +1,39 @@
+"""Summary statistics for a list of numbers: min, max, mean, median, quartiles."""
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class DistributionSummaryTool(Tool):
+    """Compute distribution summary: min, max, mean, median, Q1, Q3."""
+
+    name = "distribution_summary"
+    description = "Summary of numeric distribution: min, max, mean, median, quartiles."
+    input_schema = {
+        "type": "object",
+        "properties": {"values": {"type": "array", "description": "List of numbers"}},
+        "required": ["values"],
+    }
+
+    def run(self, **kwargs) -> str:
+        values = kwargs.get("values")
+        if not isinstance(values, list):
+            return "Error: values must be an array"
+        try:
+            nums = sorted(float(v) for v in values)
+        except (TypeError, ValueError):
+            return "Error: all elements must be numbers"
+        if not nums:
+            return "Error: empty list"
+        n = len(nums)
+        mean = sum(nums) / n
+        mid = n // 2
+        median = (nums[mid - 1] + nums[mid]) / 2 if n % 2 == 0 else nums[mid]
+        q1_idx = n // 4
+        q3_idx = (3 * n) // 4
+        q1 = nums[q1_idx]
+        q3 = nums[q3_idx]
+        return f"min = {nums[0]}\nmax = {nums[-1]}\nmean = {mean}\nmedian = {median}\nQ1 = {q1}\nQ3 = {q3}\nn = {n}"
+
+
+register(DistributionSummaryTool())