pyeggp 1.0.0__cp311-cp311-macosx_14_0_arm64.whl

pyeggp/__init__.py

@@ -0,0 +1,114 @@
+import atexit
+from contextlib import contextmanager
+from threading import Lock
+from typing import Iterator, List
+from io import StringIO
+import tempfile
+import csv
+
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, RegressorMixin
+from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
+from sklearn.metrics import mean_squared_error, r2_score
+
+from ._binding import (
+    unsafe_hs_pyeggp_version,
+    unsafe_hs_pyeggp_main,
+    unsafe_hs_pyeggp_run,
+    unsafe_hs_pyeggp_init,
+    unsafe_hs_pyeggp_exit,
+)
+
+VERSION: str = "1.3.0"
+
+
+_hs_rts_init: bool = False
+_hs_rts_lock: Lock = Lock()
+
+
+def hs_rts_exit() -> None:
+    global _hs_rts_lock
+    with _hs_rts_lock:
+        unsafe_hs_pyeggp_exit()
+
+
+@contextmanager
+def hs_rts_init(args: List[str] = []) -> Iterator[None]:
+    global _hs_rts_init
+    global _hs_rts_lock
+    with _hs_rts_lock:
+        if not _hs_rts_init:
+            _hs_rts_init = True
+            unsafe_hs_pyeggp_init(args)
+            atexit.register(hs_rts_exit)
+    yield None
+
+
+def version() -> str:
+    with hs_rts_init():
+        return unsafe_hs_pyeggp_version()
+
+
+def main(args: List[str] = []) -> int:
+    with hs_rts_init(args):
+        return unsafe_hs_pyeggp_main()
+
+def pyeggp_run(dataset: str, gen: int, nPop: int, maxSize: int, nTournament: int, pc: float, pm: float, nonterminals: str, loss: str, optIter: int, optRepeat: int, nParams: int, split: int, simplify: int, dumpTo: str, loadFrom: str) -> str:
+    with hs_rts_init():
+        return unsafe_hs_pyeggp_run(dataset, gen, nPop, maxSize, nTournament, pc, pm, nonterminals, loss, optIter, optRepeat, nParams, split, simplify, dumpTo, loadFrom)
+
+class PyEGGP(BaseEstimator, RegressorMixin):
+    def __init__(self, gen = 100, nPop = 100, maxSize = 15, nTournament = 3, pc = 0.9, pm = 0.3, nonterminals = "add,sub,mul,div", loss = "MSE", optIter = 50, optRepeat = 2, nParams = -1, split = 1, simplify = False, dumpTo = "", loadFrom = ""):
+        self.gen = gen
+        self.nPop = nPop
+        self.maxSize = maxSize
+        self.nTournament = nTournament
+        self.pc = pc
+        self.pm = pm
+        self.nonterminals = nonterminals
+        self.loss = loss
+        self.optIter = optIter
+        self.optRepeat = optRepeat
+        self.nParams = nParams
+        self.split = split
+        self.simplify = int(simplify)
+        self.dumpTo = dumpTo
+        self.loadFrom = loadFrom
+        self.is_fitted_ = False
+
+    def fit(self, X, y):
+        if X.ndim == 1:
+            X = X.reshape(-1,1)
+        y = y.reshape(-1, 1)
+        combined = np.hstack([X, y])
+        header = [f"x{i}" for i in range(X.shape[1])] + ["y"]
+        with tempfile.NamedTemporaryFile(mode='w+', newline='', delete=False, suffix='.csv') as temp_file:
+            writer = csv.writer(temp_file)
+            writer.writerow(header)
+            writer.writerows(combined)
+            dataset = temp_file.name
+
+        csv_data = pyeggp_run(dataset, self.gen, self.nPop, self.maxSize, self.nTournament, self.pc, self.pm, self.nonterminals, self.loss, self.optIter, self.optRepeat, self.nParams, self.split, self.simplify, self.dumpTo, self.loadFrom)
+        if len(csv_data) > 0:
+            csv_io = StringIO(csv_data.strip())
+            self.results = pd.read_csv(csv_io, header=0)
+            self.is_fitted_ = True
+        return self
+
+    def predict(self, X):
+        check_is_fitted(self)
+        return self.evaluate_best_model(self.model_, X)
+    def evaluate_best_model(self, x):
+        if x.ndim == 1:
+            x = x.reshape(-1,1)
+        t = np.array(list(map(float, self.results.iloc[-1].theta.split(";"))))
+        return eval(self.results.iloc[-1].Numpy)
+    def evaluate_model(self, ix, x):
+        if x.ndim == 1:
+            x = x.reshape(-1,1)
+        t = np.array(list(map(float, self.results.iloc[-1].theta.split(";"))))
+        return eval(self.results.iloc[i].Numpy)
+    def score(self, X, y):
+        ypred = self.evaluate_best_model(X)
+        return r2_score(y, ypred)

pyeggp/__main__.py

@@ -0,0 +1,11 @@
+import sys
+from typing import NoReturn
+import pyeggp
+
+
+def main() -> NoReturn:
+    sys.exit(pyeggp.main(sys.argv))
+
+
+if __name__ == "__main__":
+    main()

pyeggp/_binding.py

@@ -0,0 +1,20 @@
+def __bootstrap__():
+   global __bootstrap__, __file__, __loader__
+   import sys, os, pkg_resources, importlib.util
+   __file__ = pkg_resources.resource_filename(__name__,'_binding.cpython-311-darwin.so')
+   del __bootstrap__
+   if '__loader__' in globals():
+       del __loader__
+
+   old_dir = os.getcwd()
+   try:
+     os.chdir(os.path.dirname(__file__))
+
+     spec = importlib.util.spec_from_file_location(
+                __name__, __file__)
+     mod = importlib.util.module_from_spec(spec)
+     spec.loader.exec_module(mod)
+   finally:
+
+     os.chdir(old_dir)
+__bootstrap__()

pyeggp/_binding.pyi

@@ -0,0 +1,7 @@
+from typing import List
+
+def unsafe_hs_pyeggp_version() -> str: ...
+def unsafe_hs_pyeggp_main() -> int: ...
+def unsafe_hs_pyeggp_run(dataset: str, gen: int, nPop: int, maxSize: int, nTournament: int, pc: float, pm: float, nonterminals: str, loss: str, optIter: int, optRepeat: int, nParams: int, split: int, simplify: int, dumpTo: str, loadFrom: str) -> str: ...
+def unsafe_hs_pyeggp_init(args: List[str]) -> None: ...
+def unsafe_hs_pyeggp_exit() -> None: ...

pyeggp/binding.i

@@ -0,0 +1,64 @@
+%module binding
+%{
+#include "Pyeggp_stub.h"
+
+char * unsafe_hs_pyeggp_version() {
+  return hs_pyeggp_version();
+}
+
+int unsafe_hs_pyeggp_main() {
+  return hs_pyeggp_main();
+}
+
+char * unsafe_hs_pyeggp_run( char *dataset, int gens, int nPop, int maxSize, int nTournament, double pc, double pm,  char *nonterminals,  char *loss, int optIter, int optRepeat, int nParams, int split, int simplify,  char *dumpTo,  char *loadFrom ) {
+  return hs_pyeggp_run(dataset, gens, nPop, maxSize, nTournament, pc, pm, nonterminals, loss, optIter, optRepeat, nParams, split, simplify, dumpTo, loadFrom);
+}
+
+void unsafe_hs_pyeggp_init(int argc, char **argv) {
+  hs_init(&argc, &argv);
+}
+
+void unsafe_hs_pyeggp_exit() {
+  hs_exit();
+}
+
+void unsafe_py_write_stdout( char * str) {
+  PySys_FormatStdout("%s", str);
+}
+
+void unsafe_py_write_stderr( char * str) {
+  PySys_FormatStderr("%s", str);
+}
+%}
+
+%typemap(in) (int argc, char **argv) {
+  /* Check if is a list */
+  if (PyList_Check($input)) {
+    int i;
+    $1 = PyList_Size($input);
+    $2 = (char **) malloc(($1+1)*sizeof(char *));
+    for (i = 0; i < $1; i++) {
+      PyObject *o = PyList_GetItem($input, i);
+      if (PyUnicode_Check(o)) {
+        $2[i] = (char *) PyUnicode_AsUTF8AndSize(o, 0);
+      } else {
+        PyErr_SetString(PyExc_TypeError, "list must contain strings");
+        SWIG_fail;
+      }
+    }
+    $2[i] = 0;
+  } else {
+    PyErr_SetString(PyExc_TypeError, "not a list");
+    SWIG_fail;
+  }
+}
+
+%typemap(freearg) (int argc, char **argv) {
+  free((char *) $2);
+}
+
+char * unsafe_hs_pyeggp_version();
+int unsafe_hs_pyeggp_main();
+char * unsafe_hs_pyeggp_run( char *dataset, int gens, int nPop, int maxSize, int nTournament, double p, double pm,  char *nonterminals,  char *loss, int optIter, int optRepeat, int nParams, int split, int simplify,  char *dumpTo,  char *loadFrom);
+void unsafe_hs_pyeggp_init(int argc, char **argv);
+void unsafe_hs_pyeggp_exit();

pyeggp/binding.py

@@ -0,0 +1,76 @@
+# This file was automatically generated by SWIG (https://www.swig.org).
+# Version 4.3.0
+#
+# Do not make changes to this file unless you know what you are doing - modify
+# the SWIG interface file instead.
+
+from sys import version_info as _swig_python_version_info
+# Import the low-level C/C++ module
+if __package__ or "." in __name__:
+    from . import _binding
+else:
+    import _binding
+
+try:
+    import builtins as __builtin__
+except ImportError:
+    import __builtin__
+
+def _swig_repr(self):
+    try:
+        strthis = "proxy of " + self.this.__repr__()
+    except __builtin__.Exception:
+        strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+
+def _swig_setattr_nondynamic_instance_variable(set):
+    def set_instance_attr(self, name, value):
+        if name == "this":
+            set(self, name, value)
+        elif name == "thisown":
+            self.this.own(value)
+        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
+            set(self, name, value)
+        else:
+            raise AttributeError("You cannot add instance attributes to %s" % self)
+    return set_instance_attr
+
+
+def _swig_setattr_nondynamic_class_variable(set):
+    def set_class_attr(cls, name, value):
+        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
+            set(cls, name, value)
+        else:
+            raise AttributeError("You cannot add class attributes to %s" % cls)
+    return set_class_attr
+
+
+def _swig_add_metaclass(metaclass):
+    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
+    def wrapper(cls):
+        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
+    return wrapper
+
+
+class _SwigNonDynamicMeta(type):
+    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
+    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
+
+
+
+def unsafe_hs_pyeggp_version():
+    return _binding.unsafe_hs_pyeggp_version()
+
+def unsafe_hs_pyeggp_main():
+    return _binding.unsafe_hs_pyeggp_main()
+
+def unsafe_hs_pyeggp_run(dataset, gens, nPop, maxSize, nTournament, p, pm, nonterminals, loss, optIter, optRepeat, nParams, split, simplify, dumpTo, loadFrom):
+    return _binding.unsafe_hs_pyeggp_run(dataset, gens, nPop, maxSize, nTournament, p, pm, nonterminals, loss, optIter, optRepeat, nParams, split, simplify, dumpTo, loadFrom)
+
+def unsafe_hs_pyeggp_init(argc):
+    return _binding.unsafe_hs_pyeggp_init(argc)
+
+def unsafe_hs_pyeggp_exit():
+    return _binding.unsafe_hs_pyeggp_exit()
+

pyeggp/typing.py

@@ -0,0 +1,14 @@
+import sys
+
+from typing import List
+
+if sys.version_info < (3, 8):
+    from typing_extensions import Protocol
+else:
+    from typing import Protocol
+
+
+class Session(Protocol):
+    def version(self) -> str: ...
+    def main(self, args: List[str] = []) -> int: ...
+    def pyeggp_run(self, dataset: str, gen: int, nPop: int, maxSize: int, nTournament: int, pc: float, pm: float, nonterminals: str, loss: str, optIter: int, optRepeat: int, nParams: int, split: int, simplify: int, dumpTo: str, loadFrom: str) -> str: ...