turingbot 3.2.0__tar.gz

turingbot-3.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TuringBot Software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

turingbot-3.2.0/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: turingbot
+Version: 3.2.0
+Summary: Python interface for TuringBot, a symbolic regression software that discovers mathematical formulas from data
+Author: TuringBot Software
+License-Expression: MIT
+Project-URL: Homepage, https://turingbotsoftware.com
+Project-URL: Documentation, https://turingbotsoftware.com/documentation.html
+Project-URL: Repository, https://github.com/turingbotsoftware/turingbot-python
+Project-URL: Download, https://turingbotsoftware.com/download.html
+Keywords: symbolic regression,symbolic regression software,machine learning,formula discovery,scientific computing,curve fitting,data science,mathematical modeling,simulated annealing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# TuringBot Python Library
+
+Python interface for [TuringBot](https://turingbotsoftware.com), a symbolic regression software that discovers mathematical formulas from data.
+
+TuringBot uses simulated annealing to search the space of possible mathematical expressions, finding accurate and compact formulas that describe your data. It supports 15 search metrics, train/test splits, and a wide range of mathematical functions.
+
+## Installation
+
+```bash
+pip install turingbot
+```
+
+You also need the TuringBot desktop application installed. Download it from [turingbotsoftware.com/download.html](https://turingbotsoftware.com/download.html).
+
+## Quick start
+
+```python
+import time
+from turingbot import simulation
+
+sim = simulation()
+
+# Start a symbolic regression search
+# TuringBot is detected automatically if installed in the default location
+sim.start_process(
+    input_file="your_data.csv",  # CSV with input columns + target column
+    search_metric=4,             # RMS error
+    threads=4,
+)
+
+# Let TuringBot search for formulas
+time.sleep(60)
+
+# Read the best formulas found so far
+sim.refresh_functions()
+for f in sim.functions:
+    print(f)
+
+# Stop the search
+sim.terminate_process()
+```
+
+Or using the context manager:
+
+```python
+import time
+from turingbot import simulation
+
+with simulation() as sim:
+    sim.start_process(
+        input_file="your_data.csv",
+        search_metric=4,
+        threads=4,
+    )
+
+    time.sleep(60)
+    sim.refresh_functions()
+
+    for f in sim.functions:
+        print(f)
+```
+
+If TuringBot is installed in a non-default location, pass the path explicitly:
+
+```python
+sim.start_process(
+    input_file="your_data.csv",
+    path="/custom/path/to/TuringBot",
+)
+```
+
+Default paths checked automatically:
+
+| OS | Path |
+|----|------|
+| Windows | `C:\Program Files (x86)\TuringBot\TuringBot.exe` |
+| macOS | `/Applications/TuringBot.app/Contents/MacOS/TuringBot` |
+| Linux | `/usr/lib/turingbot/TuringBot` |
+
+## Using numpy arrays and pandas DataFrames
+
+You can pass numpy arrays or pandas DataFrames directly instead of file paths:
+
+```python
+import numpy as np
+from turingbot import simulation
+
+# Generate some data: y = 2*x1 + x2^2
+data = np.column_stack([
+    x1 := np.random.rand(100),
+    x2 := np.random.rand(100),
+    2 * x1 + x2 ** 2,
+])
+
+with simulation() as sim:
+    sim.start_process(
+        input_file=data,
+        column_names=["x1", "x2", "y"],
+    )
+    # ...
+```
+
+If `column_names` is not provided, TuringBot will use its default names (`col1`, `col2`, ...).
+
+Pandas DataFrames work the same way, and column names are preserved automatically:
+
+```python
+import pandas as pd
+from turingbot import simulation
+
+df = pd.read_csv("your_data.csv")
+
+with simulation() as sim:
+    sim.start_process(input_file=df)
+    # ...
+```
+
+## Input format
+
+The input file should be a CSV or TXT file where the last column is the target variable. Example:
+
+```
+x1,x2,y
+0.1,0.2,0.24
+0.3,0.4,0.55
+0.5,0.6,0.81
+```
+
+## Search metrics
+
+| ID | Metric |
+|----|--------|
+| 1  | Mean relative error |
+| 2  | Classification accuracy |
+| 3  | Mean error |
+| 4  | RMS error (default) |
+| 5  | F-score |
+| 6  | Correlation coefficient |
+| 7  | Hybrid (CC + RMS) |
+| 8  | Maximum error |
+| 9  | Maximum relative error |
+| 10 | Nash-Sutcliffe efficiency |
+| 11 | Binary cross-entropy |
+| 12 | Matthews correlation coefficient |
+| 13 | Residual sum of squares |
+| 14 | Root mean squared log error |
+| 15 | Percentile error |
+
+## Parameters
+
+See the full list of parameters in the `start_process` [docstring](https://turingbotsoftware.com/documentation.html), including:
+
+- `threads` -- Number of threads
+- `train_test_split` -- Train/test split ratio
+- `maximum_formula_complexity` -- Max complexity of formulas
+- `integer_constants` -- Restrict to integer constants
+- `normalize_dataset` -- Normalize input data
+- `allowed_functions` -- Restrict which math functions to use
+- `custom_formula` -- Provide a formula template
+
+## Documentation
+
+Full documentation: [turingbotsoftware.com/documentation.html](https://turingbotsoftware.com/documentation.html)
+
+## License
+
+MIT

turingbot-3.2.0/README.md

@@ -0,0 +1,167 @@
+# TuringBot Python Library
+
+Python interface for [TuringBot](https://turingbotsoftware.com), a symbolic regression software that discovers mathematical formulas from data.
+
+TuringBot uses simulated annealing to search the space of possible mathematical expressions, finding accurate and compact formulas that describe your data. It supports 15 search metrics, train/test splits, and a wide range of mathematical functions.
+
+## Installation
+
+```bash
+pip install turingbot
+```
+
+You also need the TuringBot desktop application installed. Download it from [turingbotsoftware.com/download.html](https://turingbotsoftware.com/download.html).
+
+## Quick start
+
+```python
+import time
+from turingbot import simulation
+
+sim = simulation()
+
+# Start a symbolic regression search
+# TuringBot is detected automatically if installed in the default location
+sim.start_process(
+    input_file="your_data.csv",  # CSV with input columns + target column
+    search_metric=4,             # RMS error
+    threads=4,
+)
+
+# Let TuringBot search for formulas
+time.sleep(60)
+
+# Read the best formulas found so far
+sim.refresh_functions()
+for f in sim.functions:
+    print(f)
+
+# Stop the search
+sim.terminate_process()
+```
+
+Or using the context manager:
+
+```python
+import time
+from turingbot import simulation
+
+with simulation() as sim:
+    sim.start_process(
+        input_file="your_data.csv",
+        search_metric=4,
+        threads=4,
+    )
+
+    time.sleep(60)
+    sim.refresh_functions()
+
+    for f in sim.functions:
+        print(f)
+```
+
+If TuringBot is installed in a non-default location, pass the path explicitly:
+
+```python
+sim.start_process(
+    input_file="your_data.csv",
+    path="/custom/path/to/TuringBot",
+)
+```
+
+Default paths checked automatically:
+
+| OS | Path |
+|----|------|
+| Windows | `C:\Program Files (x86)\TuringBot\TuringBot.exe` |
+| macOS | `/Applications/TuringBot.app/Contents/MacOS/TuringBot` |
+| Linux | `/usr/lib/turingbot/TuringBot` |
+
+## Using numpy arrays and pandas DataFrames
+
+You can pass numpy arrays or pandas DataFrames directly instead of file paths:
+
+```python
+import numpy as np
+from turingbot import simulation
+
+# Generate some data: y = 2*x1 + x2^2
+data = np.column_stack([
+    x1 := np.random.rand(100),
+    x2 := np.random.rand(100),
+    2 * x1 + x2 ** 2,
+])
+
+with simulation() as sim:
+    sim.start_process(
+        input_file=data,
+        column_names=["x1", "x2", "y"],
+    )
+    # ...
+```
+
+If `column_names` is not provided, TuringBot will use its default names (`col1`, `col2`, ...).
+
+Pandas DataFrames work the same way, and column names are preserved automatically:
+
+```python
+import pandas as pd
+from turingbot import simulation
+
+df = pd.read_csv("your_data.csv")
+
+with simulation() as sim:
+    sim.start_process(input_file=df)
+    # ...
+```
+
+## Input format
+
+The input file should be a CSV or TXT file where the last column is the target variable. Example:
+
+```
+x1,x2,y
+0.1,0.2,0.24
+0.3,0.4,0.55
+0.5,0.6,0.81
+```
+
+## Search metrics
+
+| ID | Metric |
+|----|--------|
+| 1  | Mean relative error |
+| 2  | Classification accuracy |
+| 3  | Mean error |
+| 4  | RMS error (default) |
+| 5  | F-score |
+| 6  | Correlation coefficient |
+| 7  | Hybrid (CC + RMS) |
+| 8  | Maximum error |
+| 9  | Maximum relative error |
+| 10 | Nash-Sutcliffe efficiency |
+| 11 | Binary cross-entropy |
+| 12 | Matthews correlation coefficient |
+| 13 | Residual sum of squares |
+| 14 | Root mean squared log error |
+| 15 | Percentile error |
+
+## Parameters
+
+See the full list of parameters in the `start_process` [docstring](https://turingbotsoftware.com/documentation.html), including:
+
+- `threads` -- Number of threads
+- `train_test_split` -- Train/test split ratio
+- `maximum_formula_complexity` -- Max complexity of formulas
+- `integer_constants` -- Restrict to integer constants
+- `normalize_dataset` -- Normalize input data
+- `allowed_functions` -- Restrict which math functions to use
+- `custom_formula` -- Provide a formula template
+
+## Documentation
+
+Full documentation: [turingbotsoftware.com/documentation.html](https://turingbotsoftware.com/documentation.html)
+
+## License
+
+MIT

turingbot-3.2.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "turingbot"
+version = "3.2.0"
+description = "Python interface for TuringBot, a symbolic regression software that discovers mathematical formulas from data"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.7"
+authors = [
+    {name = "TuringBot Software"},
+]
+keywords = [
+    "symbolic regression",
+    "symbolic regression software",
+    "machine learning",
+    "formula discovery",
+    "scientific computing",
+    "curve fitting",
+    "data science",
+    "mathematical modeling",
+    "simulated annealing",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+
+[project.urls]
+Homepage = "https://turingbotsoftware.com"
+Documentation = "https://turingbotsoftware.com/documentation.html"
+Repository = "https://github.com/turingbotsoftware/turingbot-python"
+Download = "https://turingbotsoftware.com/download.html"

turingbot-3.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

turingbot-3.2.0/turingbot/__init__.py

@@ -0,0 +1,4 @@
+from .turingbot import simulation, find_executable
+
+__version__ = "3.2.0"
+__all__ = ["simulation", "find_executable"]

turingbot-3.2.0/turingbot/turingbot.py

@@ -0,0 +1,394 @@
+import os
+import platform
+import random
+import shutil
+import subprocess
+import tempfile
+
+if os.name != "nt":
+    import signal
+
+_DEFAULT_PATHS = {
+    "Windows": [
+        r"C:\Program Files (x86)\TuringBot\TuringBot.exe",
+        r"C:\Program Files\TuringBot\TuringBot.exe",
+    ],
+    "Darwin": [
+        "/Applications/TuringBot.app/Contents/MacOS/TuringBot",
+    ],
+    "Linux": [
+        "/usr/lib/turingbot/TuringBot",
+        "/usr/local/lib/turingbot/TuringBot",
+    ],
+}
+
+
+def find_executable():
+    """Auto-detect the TuringBot executable path.
+
+    Checks the default installation paths for the current OS, then
+    falls back to looking for 'turingbot' or 'TuringBot' on PATH.
+
+    Returns the path as a string, or None if not found.
+    """
+    system = platform.system()
+    for p in _DEFAULT_PATHS.get(system, []):
+        if os.path.isfile(p):
+            return p
+
+    # Fall back to PATH lookup
+    for name in ("turingbot", "TuringBot"):
+        found = shutil.which(name)
+        if found:
+            return found
+
+    return None
+
+
+def _save_array_to_csv(data, column_names=None):
+    """Save a numpy array or pandas DataFrame to a temporary CSV file.
+
+    Returns the path to the temporary file.
+    """
+    fd, path = tempfile.mkstemp(suffix=".csv", prefix="turingbot_input_")
+    try:
+        # pandas DataFrame
+        if hasattr(data, "to_csv"):
+            os.close(fd)
+            data.to_csv(path, index=False)
+            return path
+
+        # numpy array
+        import numpy as np
+        data = np.asarray(data)
+        if data.ndim != 2:
+            raise ValueError(
+                f"Expected a 2D array, got {data.ndim}D. "
+                "Reshape your data so that rows are samples and columns are variables."
+            )
+
+        os.close(fd)
+        header = ""
+        if column_names is not None:
+            if len(column_names) != data.shape[1]:
+                raise ValueError(
+                    f"column_names has {len(column_names)} names but "
+                    f"data has {data.shape[1]} columns."
+                )
+            header = ",".join(str(c) for c in column_names)
+
+        np.savetxt(path, data, delimiter=",", header=header, comments="")
+        return path
+    except Exception:
+        if os.path.exists(path):
+            os.remove(path)
+        raise
+
+
+class simulation:
+    def __init__(self):
+        self.functions = []
+        self.process = None
+        self._outfile = None
+        self._outfile_is_temp = False
+        self._infile = None
+        self._infile_is_temp = False
+        self.info = None
+
+    def parse_lines(self, lines):
+        functions = []
+        self.info = lines[0].strip()
+
+        for i in range(2, len(lines)):
+            functions.append(lines[i].strip().split())
+            functions[-1][0] = int(functions[-1][0])
+            functions[-1][1] = float(functions[-1][1])
+            if len(functions[-1]) == 4:
+                functions[-1][2] = float(functions[-1][2])
+
+        return functions
+
+    def start_process(
+        self,
+        path: str = None,
+        input_file=None,
+        config: str = None,
+        column_names: list = None,
+        threads: int = None,
+        outfile: str = None,
+        predictions_file: str = None,
+        formulas_file: str = None,
+        search_metric: int = None,
+        train_test_split: int = None,
+        test_sample: int = None,
+        train_test_seed: int = None,
+        bound_search_mode: int = None,
+        maximum_formula_complexity: int = None,
+        history_size: int = None,
+        max_occurrences_per_variable: int = None,
+        distinct_variables_min: int = None,
+        distinct_variables_max: int = None,
+        constants_min: int = None,
+        constants_max: int = None,
+        fscore_beta: float = None,
+        percentile: float = None,
+        integer_constants: bool = False,
+        normalize_dataset: bool = False,
+        allow_target_delay: bool = False,
+        force_all_variables: bool = False,
+        custom_formula: str = None,
+        allowed_functions: str = None,
+    ):
+        """
+        Start the process with the specified configuration and dataset.
+
+        Parameters:
+        -----------
+        path : str, optional
+            Path to the TuringBot executable. If not provided, the default
+            installation path for your OS will be used automatically.
+        input_file : str, numpy.ndarray, or pandas.DataFrame
+            The input data. Can be a file path (str), a 2D numpy array,
+            or a pandas DataFrame. When an array or DataFrame is passed,
+            it is saved to a temporary CSV file automatically.
+        config : str, optional
+            Path to the configuration file.
+        column_names : list of str, optional
+            Column names for the data. Only used when input_file is a
+            numpy array. Ignored for DataFrames (which have their own
+            column names) and file paths.
+        threads : int, optional
+            Number of threads to use.
+        outfile : str, optional
+            Output file path.
+        predictions_file : str, optional
+            File to store predictions.
+        formulas_file : str, optional
+            File to store generated formulas.
+        search_metric : int, optional
+            Search metric to use. Default is 4 (RMS error).
+            Options:
+            1: Mean relative error
+            2: Classification accuracy
+            3: Mean error
+            4: RMS error (default)
+            5: F-score
+            6: Correlation coefficient
+            7: Hybrid (CC + RMS)
+            8: Maximum error
+            9: Maximum relative error
+            10: Nash-Sutcliffe efficiency
+            11: Binary cross-entropy
+            12: Matthews correlation coefficient (MCC)
+            13: Residual sum of squares (RSS)
+            14: Root mean squared log error (RMSLE)
+            15: Percentile error
+        train_test_split : int, optional
+            Train/test split. Default is -1 (no test sample).
+            Options:
+            -1: No test sample (default)
+            50, 60, 70, 75, 80: Percentage split for training data
+            100, 1000, 10000: Predefined row counts for training
+            Negative values (e.g., -200): Use 200 rows for training
+        test_sample : int, optional
+            How to select test samples. Default is 1 (random).
+            Options:
+            1: Chosen randomly (default)
+            2: The last points
+        train_test_seed : int, optional
+            Random seed for train/test split generation. Default is -1 (no specific seed).
+        bound_search_mode : int, optional
+            Whether to use bound search mode. Default is 0 (deactivated).
+            Options:
+            0: Deactivated (default)
+            1: Lower bound search
+            2: Upper bound search
+        maximum_formula_complexity : int, optional
+            Maximum formula complexity. Default is 60.
+        history_size : int, optional
+            History size for the optimization process. Default is 20.
+        max_occurrences_per_variable : int, optional
+            Maximum occurrences per variable. Default is -1 (no limit).
+        distinct_variables_min : int, optional
+            Minimum number of distinct variables. Default is -1 (no limit).
+        distinct_variables_max : int, optional
+            Maximum number of distinct variables. Default is -1 (no limit).
+        constants_min : int, optional
+            Minimum number of constants. Default is -1 (no limit).
+        constants_max : int, optional
+            Maximum number of constants. Default is -1 (no limit).
+        fscore_beta : float, optional
+            Beta parameter for F-score. Default is 1.
+        percentile : float, optional
+            Percentile for the Percentile error metric. Default is 0.5.
+        integer_constants : bool, optional
+            Whether to use integer constants only. Default is False (disabled).
+        normalize_dataset : bool, optional
+            Whether to normalize the dataset before optimization. Default is False (no normalization).
+        allow_target_delay : bool, optional
+            Whether to allow the target variable in lag functions. Default is False (not allowed).
+        force_all_variables : bool, optional
+            Whether to force the solution to include all input variables. Default is False (not forced).
+        custom_formula : str, optional
+            Custom formula for the search. If not provided, the last column will be treated as the target variable.
+        allowed_functions : str, optional
+            Allowed functions for the formula search. Default: "+ * / pow fmod sin cos tan asin acos atan exp log log2 log10 sqrt sinh cosh tanh asinh acosh atanh abs floor ceil round sign tgamma lgamma erf"
+        """
+
+        self.functions = []
+
+        if input_file is None:
+            raise ValueError("input_file is required.")
+
+        # Convert numpy arrays and pandas DataFrames to a temp CSV
+        if not isinstance(input_file, str):
+            input_file = _save_array_to_csv(input_file, column_names)
+            self._infile = input_file
+            self._infile_is_temp = True
+        else:
+            self._infile = input_file
+            self._infile_is_temp = False
+
+        if path is None:
+            path = find_executable()
+            if path is None:
+                raise FileNotFoundError(
+                    "TuringBot executable not found. Install TuringBot from "
+                    "https://turingbotsoftware.com/download.html or pass the "
+                    "path= argument explicitly."
+                )
+
+        if not os.path.isfile(input_file):
+            raise FileNotFoundError(f"Input file does not exist: {input_file}")
+
+        if not os.path.isfile(path):
+            raise FileNotFoundError(f"Executable path is incorrect: {path}")
+
+        if config is not None and not os.path.isfile(config):
+            raise FileNotFoundError(f"Configuration file does not exist: {config}")
+
+        path = f'"{path}"'
+        input_file = f'"{input_file}"'
+        if outfile is None:
+            if os.name == "nt":
+                self._outfile = tempfile.gettempdir() + r"\turingbot_%d.txt" % random.randint(1000000000, 9999999999)
+            else:
+                self._outfile = tempfile.gettempdir() + "/turingbot_%d.txt" % random.randint(1000000000, 9999999999)
+            self._outfile_is_temp = True
+        else:
+            self._outfile = outfile
+            self._outfile_is_temp = False
+
+        if self.process is not None:
+            self.process.kill()
+
+        if os.name == "nt":
+            cmd = f"{path} {input_file} --outfile {self._outfile}"
+        elif os.name == "posix":
+            cmd = f"exec {path} {input_file} --outfile {self._outfile} 1>/dev/null 2>/dev/null"
+        else:
+            cmd = f"exec stdbuf -oL {path} {input_file} --outfile {self._outfile} 1>/dev/null 2>/dev/null"
+
+        if config is not None:
+            cmd = f"{cmd} {config}"
+        else:
+            if search_metric is not None:
+                cmd = f"{cmd} --search-metric {search_metric}"
+            if train_test_split is not None:
+                cmd = f"{cmd} --train-test-split {train_test_split}"
+            if test_sample is not None:
+                cmd = f"{cmd} --test-sample {test_sample}"
+            if train_test_seed is not None:
+                cmd = f"{cmd} --train-test-seed {train_test_seed}"
+            if bound_search_mode is not None:
+                cmd = f"{cmd} --bound-search-mode {bound_search_mode}"
+            if maximum_formula_complexity is not None:
+                cmd = f"{cmd} --maximum-formula-complexity {maximum_formula_complexity}"
+            if history_size is not None:
+                cmd = f"{cmd} --history-size {history_size}"
+            if max_occurrences_per_variable is not None:
+                cmd = f"{cmd} --max-occurrences-per-variable {max_occurrences_per_variable}"
+            if distinct_variables_min is not None:
+                cmd = f"{cmd} --distinct-variables-min {distinct_variables_min}"
+            if distinct_variables_max is not None:
+                cmd = f"{cmd} --distinct-variables-max {distinct_variables_max}"
+            if constants_min is not None:
+                cmd = f"{cmd} --constants-min {constants_min}"
+            if constants_max is not None:
+                cmd = f"{cmd} --constants-max {constants_max}"
+            if fscore_beta is not None:
+                cmd = f"{cmd} --fscore-beta {fscore_beta}"
+            if percentile is not None:
+                cmd = f"{cmd} --percentile {percentile}"
+            if integer_constants:
+                cmd = f"{cmd} --integer-constants"
+            if normalize_dataset:
+                cmd = f"{cmd} --normalize-dataset"
+            if allow_target_delay:
+                cmd = f"{cmd} --allow-target-delay"
+            if force_all_variables:
+                cmd = f"{cmd} --force-all-variables"
+            if custom_formula is not None:
+                cmd = f"{cmd} --custom-formula \"{custom_formula}\""
+            if allowed_functions is not None:
+                cmd = f"{cmd} --allowed-functions \"{allowed_functions}\""
+
+        if threads is not None:
+            cmd = f"{cmd} --threads {int(threads)}"
+
+        if predictions_file is not None:
+            cmd = f"{cmd} --predictions-file {predictions_file}"
+
+        if formulas_file is not None:
+            cmd = f"{cmd} --formulas-file {formulas_file}"
+
+        cmd = f"{cmd} --library-parent-id {str(os.getpid())}"
+
+        if os.name == "nt":
+            self.process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL
+            )
+        else:
+            self.process = subprocess.Popen(
+                cmd,
+                shell=True,
+                encoding="utf-8",
+                preexec_fn=os.setsid
+            )
+
+    def refresh_functions(self):
+        if self._outfile and os.path.isfile(self._outfile):
+            with open(self._outfile, "r") as f:
+                lines = f.readlines()
+
+            if len(lines) > 0:
+                self.functions = self.parse_lines(lines)
+
+    def terminate_process(self):
+        try:
+            if self.process and self.process.poll() is None:
+                if os.name == "nt":
+                    self.process.terminate()
+                else:
+                    os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
+
+            if self._outfile_is_temp and self._outfile and os.path.exists(self._outfile):
+                os.remove(self._outfile)
+                self._outfile_is_temp = False
+
+            if self._infile_is_temp and self._infile and os.path.exists(self._infile):
+                os.remove(self._infile)
+                self._infile_is_temp = False
+        except Exception as error:
+            print(error)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.terminate_process()
+
+    def __del__(self):
+        self.terminate_process()

turingbot-3.2.0/turingbot.egg-info/PKG-INFO

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: turingbot
+Version: 3.2.0
+Summary: Python interface for TuringBot, a symbolic regression software that discovers mathematical formulas from data
+Author: TuringBot Software
+License-Expression: MIT
+Project-URL: Homepage, https://turingbotsoftware.com
+Project-URL: Documentation, https://turingbotsoftware.com/documentation.html
+Project-URL: Repository, https://github.com/turingbotsoftware/turingbot-python
+Project-URL: Download, https://turingbotsoftware.com/download.html
+Keywords: symbolic regression,symbolic regression software,machine learning,formula discovery,scientific computing,curve fitting,data science,mathematical modeling,simulated annealing
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# TuringBot Python Library
+
+Python interface for [TuringBot](https://turingbotsoftware.com), a symbolic regression software that discovers mathematical formulas from data.
+
+TuringBot uses simulated annealing to search the space of possible mathematical expressions, finding accurate and compact formulas that describe your data. It supports 15 search metrics, train/test splits, and a wide range of mathematical functions.
+
+## Installation
+
+```bash
+pip install turingbot
+```
+
+You also need the TuringBot desktop application installed. Download it from [turingbotsoftware.com/download.html](https://turingbotsoftware.com/download.html).
+
+## Quick start
+
+```python
+import time
+from turingbot import simulation
+
+sim = simulation()
+
+# Start a symbolic regression search
+# TuringBot is detected automatically if installed in the default location
+sim.start_process(
+    input_file="your_data.csv",  # CSV with input columns + target column
+    search_metric=4,             # RMS error
+    threads=4,
+)
+
+# Let TuringBot search for formulas
+time.sleep(60)
+
+# Read the best formulas found so far
+sim.refresh_functions()
+for f in sim.functions:
+    print(f)
+
+# Stop the search
+sim.terminate_process()
+```
+
+Or using the context manager:
+
+```python
+import time
+from turingbot import simulation
+
+with simulation() as sim:
+    sim.start_process(
+        input_file="your_data.csv",
+        search_metric=4,
+        threads=4,
+    )
+
+    time.sleep(60)
+    sim.refresh_functions()
+
+    for f in sim.functions:
+        print(f)
+```
+
+If TuringBot is installed in a non-default location, pass the path explicitly:
+
+```python
+sim.start_process(
+    input_file="your_data.csv",
+    path="/custom/path/to/TuringBot",
+)
+```
+
+Default paths checked automatically:
+
+| OS | Path |
+|----|------|
+| Windows | `C:\Program Files (x86)\TuringBot\TuringBot.exe` |
+| macOS | `/Applications/TuringBot.app/Contents/MacOS/TuringBot` |
+| Linux | `/usr/lib/turingbot/TuringBot` |
+
+## Using numpy arrays and pandas DataFrames
+
+You can pass numpy arrays or pandas DataFrames directly instead of file paths:
+
+```python
+import numpy as np
+from turingbot import simulation
+
+# Generate some data: y = 2*x1 + x2^2
+data = np.column_stack([
+    x1 := np.random.rand(100),
+    x2 := np.random.rand(100),
+    2 * x1 + x2 ** 2,
+])
+
+with simulation() as sim:
+    sim.start_process(
+        input_file=data,
+        column_names=["x1", "x2", "y"],
+    )
+    # ...
+```
+
+If `column_names` is not provided, TuringBot will use its default names (`col1`, `col2`, ...).
+
+Pandas DataFrames work the same way, and column names are preserved automatically:
+
+```python
+import pandas as pd
+from turingbot import simulation
+
+df = pd.read_csv("your_data.csv")
+
+with simulation() as sim:
+    sim.start_process(input_file=df)
+    # ...
+```
+
+## Input format
+
+The input file should be a CSV or TXT file where the last column is the target variable. Example:
+
+```
+x1,x2,y
+0.1,0.2,0.24
+0.3,0.4,0.55
+0.5,0.6,0.81
+```
+
+## Search metrics
+
+| ID | Metric |
+|----|--------|
+| 1  | Mean relative error |
+| 2  | Classification accuracy |
+| 3  | Mean error |
+| 4  | RMS error (default) |
+| 5  | F-score |
+| 6  | Correlation coefficient |
+| 7  | Hybrid (CC + RMS) |
+| 8  | Maximum error |
+| 9  | Maximum relative error |
+| 10 | Nash-Sutcliffe efficiency |
+| 11 | Binary cross-entropy |
+| 12 | Matthews correlation coefficient |
+| 13 | Residual sum of squares |
+| 14 | Root mean squared log error |
+| 15 | Percentile error |
+
+## Parameters
+
+See the full list of parameters in the `start_process` [docstring](https://turingbotsoftware.com/documentation.html), including:
+
+- `threads` -- Number of threads
+- `train_test_split` -- Train/test split ratio
+- `maximum_formula_complexity` -- Max complexity of formulas
+- `integer_constants` -- Restrict to integer constants
+- `normalize_dataset` -- Normalize input data
+- `allowed_functions` -- Restrict which math functions to use
+- `custom_formula` -- Provide a formula template
+
+## Documentation
+
+Full documentation: [turingbotsoftware.com/documentation.html](https://turingbotsoftware.com/documentation.html)
+
+## License
+
+MIT

turingbot-3.2.0/turingbot.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+turingbot/__init__.py
+turingbot/turingbot.py
+turingbot.egg-info/PKG-INFO
+turingbot.egg-info/SOURCES.txt
+turingbot.egg-info/dependency_links.txt
+turingbot.egg-info/top_level.txt

turingbot-3.2.0/turingbot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

turingbot-3.2.0/turingbot.egg-info/top_level.txt

@@ -0,0 +1 @@
+turingbot