orbital 0.2.2__tar.gz

orbital-0.2.2/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2024 orbital authors
+
+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.

orbital-0.2.2/PKG-INFO

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: orbital
+Version: 0.2.2
+Summary: Allow SKLearn predictions to run on database systems in pure SQL.
+Author: Posit Software PBC
+Author-email: Alessandro Molina <alessandro.molina@posit.co>
+License-Expression: MIT
+Keywords: database,machine learning,sql
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Database
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: SQL
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: packaging
+Requires-Dist: scikit-learn
+Requires-Dist: skl2onnx~=1.19.1
+Requires-Dist: onnx~=1.18.0
+Requires-Dist: ibis-framework<11.0.0
+Provides-Extra: test
+Requires-Dist: pandas; extra == "test"
+Requires-Dist: polars-lts-cpu; extra == "test"
+Requires-Dist: pyarrow>=19.0.1; extra == "test"
+Requires-Dist: pyarrow-hotfix; extra == "test"
+Requires-Dist: ibis-framework[duckdb]>=5.1.0; extra == "test"
+Requires-Dist: pytest-cov>=5.0.0; extra == "test"
+Requires-Dist: pytest>=8.3.2; extra == "test"
+Requires-Dist: sqlalchemy; extra == "test"
+Requires-Dist: psycopg2-binary; extra == "test"
+Requires-Dist: duckdb; extra == "test"
+Dynamic: license-file
+
+# orbital
+
+Convert SKLearn pipelines into SQL queries for execution in a database
+without the need for a Python environment.
+
+See `examples` directory for [example pipelines](https://github.com/posit-dev/orbital/tree/main/examples) and [Documentation](https://posit-dev.github.io/orbital/)
+
+**Warning**:
+
+    This is a work in progress.
+    You might encounter bugs or missing features.
+
+**Note**:
+
+    Not all transformations and models can be represented as SQL queries,
+    so orbital might not be able to implement the specific pipeline you are using.
+
+## Getting Started
+
+Install orbital:
+
+```bash
+$ pip install orbital
+```
+
+Prepare some data:
+
+```python
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+
+COLUMNS = ["sepal.length", "sepal.width", "petal.length", "petal.width"]
+
+iris = load_iris(as_frame=True)
+iris_x = iris.data.set_axis(COLUMNS, axis=1)
+
+# SQL and orbital don't like dots in column names, replace them with underscores
+iris_x.columns = COLUMNS = [cname.replace(".", "_") for cname in COLUMNS]
+
+X_train, X_test, y_train, y_test = train_test_split(
+    iris_x, iris.target, test_size=0.2, random_state=42
+)
+```
+
+Define a Scikit-Learn pipeline and train it:
+
+```python
+from sklearn.compose import ColumnTransformer
+from sklearn.linear_model import LinearRegression
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+
+pipeline = Pipeline(
+    [
+        ("preprocess", ColumnTransformer([("scaler", StandardScaler(with_std=False), COLUMNS)],
+                                        remainder="passthrough")),
+        ("linear_regression", LinearRegression()),
+    ]
+)
+pipeline.fit(X_train, y_train)
+```
+
+Convert the pipeline to orbital:
+
+```python
+import orbital
+import orbital.types
+
+orbital_pipeline = orbital.parse_pipeline(pipeline, features={
+    "sepal_length": orbital.types.DoubleColumnType(),
+    "sepal_width": orbital.types.DoubleColumnType(),
+    "petal_length": orbital.types.DoubleColumnType(),
+    "petal_width": orbital.types.DoubleColumnType(),
+})
+```
+
+You can print the pipeline to see the result:
+
+```python
+>>> print(orbital_pipeline)
+
+ParsedPipeline(
+    features={
+        sepal_length: DoubleColumnType()
+        sepal_width: DoubleColumnType()
+        petal_length: DoubleColumnType()
+        petal_width: DoubleColumnType()
+    },
+    steps=[
+        merged_columns=Concat(
+            inputs: sepal_length, sepal_width, petal_length, petal_width,
+            attributes: 
+             axis=1
+        )
+        variable1=Sub(
+            inputs: merged_columns, Su_Subcst=[5.809166666666666, 3.0616666666666665, 3.7266666666666666, 1.18333333...,
+            attributes: 
+        )
+        multiplied=MatMul(
+            inputs: variable1, coef=[-0.11633479416518255, -0.05977785171980231, 0.25491374699772246, 0.5475959...,
+            attributes: 
+        )
+        resh=Add(
+            inputs: multiplied, intercept=[0.9916666666666668],
+            attributes: 
+        )
+        variable=Reshape(
+            inputs: resh, shape_tensor=[-1, 1],
+            attributes: 
+        )
+    ],
+)
+```
+
+Now we can generate the SQL from the pipeline:
+
+```python
+sql = orbital.export_sql("DATA_TABLE", orbital_pipeline, dialect="duckdb")
+```
+
+And check the resulting query:
+
+```python
+>>> print(sql)
+
+SELECT ("t0"."sepal_length" - 5.809166666666666) * -0.11633479416518255 + 0.9916666666666668 +  
+       ("t0"."sepal_width" - 3.0616666666666665) * -0.05977785171980231 + 
+       ("t0"."petal_length" - 3.7266666666666666) * 0.25491374699772246 + 
+       ("t0"."petal_width" - 1.1833333333333333) * 0.5475959809777828 
+AS "variable" FROM "DATA_TABLE" AS "t0"
+```
+
+Once the SQL is generate, you can use it to run the pipeline on a
+database. From here on the SQL can be exported and reused in other
+places:
+
+```python
+>>> print("\nPrediction with SQL")
+>>> duckdb.register("DATA_TABLE", X_test)
+>>> print(duckdb.sql(sql).df()["variable"][:5].to_numpy())
+
+Prediction with SQL
+[ 1.23071715 -0.04010441  2.21970287  1.34966889  1.28429336]
+```
+
+We can verify that the prediction matches the one done by Scikit-Learn
+by running the scikitlearn pipeline on the same set of data:
+
+```python
+>>> print("\nPrediction with SciKit-Learn")
+>>> print(pipeline.predict(X_test)[:5])
+
+Prediction with SciKit-Learn
+[ 1.23071715 -0.04010441  2.21970287  1.34966889  1.28429336 ]
+```
+
+## Supported Models
+
+orbital currently supports the following models:
+
+-   Linear Regression
+-   Logistic Regression
+-   Lasso Regression
+-   Elastic Net
+-   Decision Tree Regressor
+-   Decision Tree Classifier
+-   Random Forest Classifier
+-   Gradient Boosting Regressor
+-   Gradient Boosting Classifier
+
+# Testing
+
+Setup testing environment:
+
+```bash
+$ uv sync --no-dev --extra test
+```
+
+Run Tests:
+
+```bash
+$ uv run pytest -v
+```
+
+Try Examples:
+
+```bash
+$ uv run examples/pipeline_lineareg.py
+```
+
+# Development
+
+Setup a development environment:
+
+```bash
+$ uv sync
+```

orbital-0.2.2/README.md

@@ -0,0 +1,197 @@
+# orbital
+
+Convert SKLearn pipelines into SQL queries for execution in a database
+without the need for a Python environment.
+
+See `examples` directory for [example pipelines](https://github.com/posit-dev/orbital/tree/main/examples) and [Documentation](https://posit-dev.github.io/orbital/)
+
+**Warning**:
+
+    This is a work in progress.
+    You might encounter bugs or missing features.
+
+**Note**:
+
+    Not all transformations and models can be represented as SQL queries,
+    so orbital might not be able to implement the specific pipeline you are using.
+
+## Getting Started
+
+Install orbital:
+
+```bash
+$ pip install orbital
+```
+
+Prepare some data:
+
+```python
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+
+COLUMNS = ["sepal.length", "sepal.width", "petal.length", "petal.width"]
+
+iris = load_iris(as_frame=True)
+iris_x = iris.data.set_axis(COLUMNS, axis=1)
+
+# SQL and orbital don't like dots in column names, replace them with underscores
+iris_x.columns = COLUMNS = [cname.replace(".", "_") for cname in COLUMNS]
+
+X_train, X_test, y_train, y_test = train_test_split(
+    iris_x, iris.target, test_size=0.2, random_state=42
+)
+```
+
+Define a Scikit-Learn pipeline and train it:
+
+```python
+from sklearn.compose import ColumnTransformer
+from sklearn.linear_model import LinearRegression
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+
+pipeline = Pipeline(
+    [
+        ("preprocess", ColumnTransformer([("scaler", StandardScaler(with_std=False), COLUMNS)],
+                                        remainder="passthrough")),
+        ("linear_regression", LinearRegression()),
+    ]
+)
+pipeline.fit(X_train, y_train)
+```
+
+Convert the pipeline to orbital:
+
+```python
+import orbital
+import orbital.types
+
+orbital_pipeline = orbital.parse_pipeline(pipeline, features={
+    "sepal_length": orbital.types.DoubleColumnType(),
+    "sepal_width": orbital.types.DoubleColumnType(),
+    "petal_length": orbital.types.DoubleColumnType(),
+    "petal_width": orbital.types.DoubleColumnType(),
+})
+```
+
+You can print the pipeline to see the result:
+
+```python
+>>> print(orbital_pipeline)
+
+ParsedPipeline(
+    features={
+        sepal_length: DoubleColumnType()
+        sepal_width: DoubleColumnType()
+        petal_length: DoubleColumnType()
+        petal_width: DoubleColumnType()
+    },
+    steps=[
+        merged_columns=Concat(
+            inputs: sepal_length, sepal_width, petal_length, petal_width,
+            attributes: 
+             axis=1
+        )
+        variable1=Sub(
+            inputs: merged_columns, Su_Subcst=[5.809166666666666, 3.0616666666666665, 3.7266666666666666, 1.18333333...,
+            attributes: 
+        )
+        multiplied=MatMul(
+            inputs: variable1, coef=[-0.11633479416518255, -0.05977785171980231, 0.25491374699772246, 0.5475959...,
+            attributes: 
+        )
+        resh=Add(
+            inputs: multiplied, intercept=[0.9916666666666668],
+            attributes: 
+        )
+        variable=Reshape(
+            inputs: resh, shape_tensor=[-1, 1],
+            attributes: 
+        )
+    ],
+)
+```
+
+Now we can generate the SQL from the pipeline:
+
+```python
+sql = orbital.export_sql("DATA_TABLE", orbital_pipeline, dialect="duckdb")
+```
+
+And check the resulting query:
+
+```python
+>>> print(sql)
+
+SELECT ("t0"."sepal_length" - 5.809166666666666) * -0.11633479416518255 + 0.9916666666666668 +  
+       ("t0"."sepal_width" - 3.0616666666666665) * -0.05977785171980231 + 
+       ("t0"."petal_length" - 3.7266666666666666) * 0.25491374699772246 + 
+       ("t0"."petal_width" - 1.1833333333333333) * 0.5475959809777828 
+AS "variable" FROM "DATA_TABLE" AS "t0"
+```
+
+Once the SQL is generate, you can use it to run the pipeline on a
+database. From here on the SQL can be exported and reused in other
+places:
+
+```python
+>>> print("\nPrediction with SQL")
+>>> duckdb.register("DATA_TABLE", X_test)
+>>> print(duckdb.sql(sql).df()["variable"][:5].to_numpy())
+
+Prediction with SQL
+[ 1.23071715 -0.04010441  2.21970287  1.34966889  1.28429336]
+```
+
+We can verify that the prediction matches the one done by Scikit-Learn
+by running the scikitlearn pipeline on the same set of data:
+
+```python
+>>> print("\nPrediction with SciKit-Learn")
+>>> print(pipeline.predict(X_test)[:5])
+
+Prediction with SciKit-Learn
+[ 1.23071715 -0.04010441  2.21970287  1.34966889  1.28429336 ]
+```
+
+## Supported Models
+
+orbital currently supports the following models:
+
+-   Linear Regression
+-   Logistic Regression
+-   Lasso Regression
+-   Elastic Net
+-   Decision Tree Regressor
+-   Decision Tree Classifier
+-   Random Forest Classifier
+-   Gradient Boosting Regressor
+-   Gradient Boosting Classifier
+
+# Testing
+
+Setup testing environment:
+
+```bash
+$ uv sync --no-dev --extra test
+```
+
+Run Tests:
+
+```bash
+$ uv run pytest -v
+```
+
+Try Examples:
+
+```bash
+$ uv run examples/pipeline_lineareg.py
+```
+
+# Development
+
+Setup a development environment:
+
+```bash
+$ uv sync
+```

orbital-0.2.2/pyproject.toml

@@ -0,0 +1,116 @@
+[build-system]
+requires = [
+    "setuptools>=77.0.0",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "orbital"
+version = "0.2.2"
+description = "Allow SKLearn predictions to run on database systems in pure SQL."
+keywords = ["database", "machine learning", "sql"]
+readme = { file = "README.md", content-type = "text/markdown" }
+license = "MIT"
+authors = [
+  { name = "Alessandro Molina", email = "alessandro.molina@posit.co" },
+  { name = "Posit Software PBC" }
+]
+classifiers = [
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX",
+  "Operating System :: Unix",
+  "Operating System :: MacOS",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Intended Audience :: Science/Research",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Database",
+  "Programming Language :: Python",
+  "Programming Language :: SQL",
+]
+
+requires-python = ">=3.9"
+dependencies = [
+  "packaging",  # somehow required by skl2onnx/operator_converters
+  "scikit-learn",
+  "skl2onnx~=1.19.1",
+  "onnx~=1.18.0",
+  "ibis-framework<11.0.0",
+]
+
+[project.optional-dependencies]
+test = [
+  "pandas",
+  "polars-lts-cpu",  # For testing we prefer compatibility over performance.
+  "pyarrow>=19.0.1",
+  "pyarrow-hotfix",  # Ibis seems to demand this even on versions without hotfixes
+  "ibis-framework[duckdb]>=5.1.0",
+  "pytest-cov>=5.0.0",
+  "pytest>=8.3.2",
+  "sqlalchemy",
+  "psycopg2-binary",
+  "duckdb",
+]
+
+[tool.uv]
+dev-dependencies = [
+    # Need to repeat test dependencies
+    # uv doesn't allow to merge them with extras
+    # and we don't want users to know that they need to run
+    # uv sync with extras.
+    "pandas",
+    "polars-lts-cpu",
+    "pyarrow",
+    "pyarrow-hotfix",
+    "pytest-cov>=5.0.0",
+    "pytest>=8.3.2",
+    "ibis-framework[duckdb]>=5.1.0",
+    # Necessary for development workflow
+    "mypy>=1.11.2",
+    "pre-commit",
+    "ruff>=0.6.3",
+    "mkdocs-material",
+    "mkdocstrings[python]",
+    "pydot",
+    "onnxruntime",
+    "onnxscript",
+    "sqlalchemy",
+    "psycopg2-binary",
+    "duckdb",
+]
+
+
+[tool.setuptools.packages.find]
+where = ["src"]
+exclude = ["tests"]
+
+[tool.pytest.ini_options]
+addopts = "--doctest-modules --cov=src --cov-report term-missing"
+testpaths = ["tests"]
+
+[tool.mypy]
+ignore_missing_imports = true
+mypy_path = "$MYPY_CONFIG_FILE_DIR/src"
+packages = ["orbital"]
+
+[tool.ruff]
+target-version = "py39"
+src = ["src"]
+extend-exclude = ["docs", "tests", "examples", "proxypackage"]
+output-format = "grouped"
+lint.select = [
+  "E4", "E7", "E9",
+  "F",
+  "I001",
+  "D100", "D101", "D102", "D103", 
+  "D104", "D107", "D417",
+  "ANN001", "ANN201", "ANN202", 
+  "ANN204", "ANN205", "ANN206"
+]

orbital-0.2.2/setup.cfg

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

orbital-0.2.2/src/orbital/__init__.py

@@ -0,0 +1,14 @@
+"""orbital, translate scikit-learn pipelines into SQL queries
+
+orbital is a library for translating **scikit-learn** pipelines
+into **SQL queries** and **Ibis expressions**.
+
+It provides a way to execute machine learning models on databases without
+the need for a python runtime environment.
+"""
+
+from .ast import parse_pipeline
+from .sql import export_sql
+from .translate import ResultsProjection, translate
+
+__all__ = ["parse_pipeline", "translate", "export_sql", "ResultsProjection"]

orbital-0.2.2/src/orbital/_utils/onnx.py

@@ -0,0 +1,39 @@
+import typing
+
+import onnx
+import onnx.helper
+
+ListVariableTypes = typing.Union[list[int], list[float], list[str]]
+VariableTypes = typing.Union[float, int, str, ListVariableTypes]
+
+
+def get_initializer_data(var: onnx.TensorProto) -> VariableTypes:
+    """Given a constant initializer, return its value"""
+    attr_name = onnx.helper.tensor_dtype_to_field(var.data_type)
+    values = list(getattr(var, attr_name))
+    dimensions = getattr(var, "dims", None)
+
+    if not dimensions and len(values) == 1:
+        # If there are no dimensions, it's a scalar
+        # and we should return the single value
+        return values[0]
+    return values
+
+
+def get_attr_value(attr: onnx.AttributeProto) -> VariableTypes:
+    """Given an attribute, return its value"""
+    # TODO: Check if it can be replaced with onnx.helper.get_attribute_value
+    if attr.type == attr.INTS:
+        return list(attr.ints)
+    elif attr.type == attr.FLOATS:
+        return list(attr.floats)
+    elif attr.type == attr.STRINGS:
+        return [s.decode("utf-8") if isinstance(s, bytes) else s for s in attr.strings]
+    elif attr.type == attr.INT:
+        return attr.i
+    elif attr.type == attr.FLOAT:
+        return attr.f
+    elif attr.type == attr.STRING:
+        return attr.s.decode("utf-8") if isinstance(attr.s, bytes) else attr.s
+    else:
+        raise ValueError(f"Unsupported attribute type: {attr.type}")