codestr 0.3.0__tar.gz → 0.3.2__tar.gz

{codestr-0.3.0 → codestr-0.3.2}/.github/workflows/ci.yml

@@ -33,3 +33,20 @@ jobs:
         run: |
           uv sync --extra test
           uv run pytest tests/ -v
+
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+      - name: Install test dependencies
+        run: uv sync --extra test
+      - name: Enforce branch coverage
+        run: |
+          uv run pytest tests/ \
+            --cov=src/codestr \
+            --cov-branch \
+            --cov-report=term-missing \
+            --cov-fail-under=90

{codestr-0.3.0 → codestr-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: codestr
-Version: 0.3.0
+Version: 0.3.2
 Summary: DSL → Polars Expr compile engine for quantitative factor mining
 Project-URL: Repository, https://github.com/huangbogeng/codestr
 Author: huangbogeng
@@ -18,7 +18,7 @@ Requires-Python: >=3.10
 Requires-Dist: lark<2.0,>=1.0
 Requires-Dist: loguru<1.0,>=0.7
 Requires-Dist: numpy<3.0,>=1.26
-Requires-Dist: polars>=1.42.1
+Requires-Dist: polars>=1.44.1
 Requires-Dist: toolz<2.0,>=1.0
 Provides-Extra: dev
 Requires-Dist: mypy>=1.10; extra == 'dev'
@@ -71,12 +71,13 @@ result = cs.sql(
 print(result)
 ```
 
-## 两种 API 模式
+## API 模式
 
 | 模式 | API | 行为 |
 |------|-----|------|
 | **纯编译** | `cs.compile(expr) -> pl.Expr` | 无副作用，返回 Polars 表达式 |
 | **交互式** | `cs.sql(expr, lazy=False) -> pl.DataFrame` | 有状态，自动缓存与复用 |
+| **静态验证** | `cs.validate_expr(*exprs) -> list[dict]` | 无副作用，按当前 schema 干编译 |
 
 ```python
 # 纯编译 — 表达式可被任意 DataFrame 消费
@@ -88,6 +89,24 @@ cs.sql("close + volume as total")
 cs.sql("ts_mean(total, 5) as total_ma5")  # 复用上一步的 total
 ```
 
+### 静态验证
+
+`validate_expr()` 复用 `sql()` 的 planner，在当前 LazyFrame schema 上解析
+UDF、列引用、类型兼容性和混合窗口，但只调用 `collect_schema()`，不会
+`collect()` 数据或修改引擎缓存：
+
+```python
+results = cs.validate_expr(
+    "sin(1.0) as invalid",
+    "ts_mean(cs_moderate(close), 5) as factor",
+)
+```
+
+每个结果包含 `expr`、`valid`、`stage`、`error_type` 和 `message`。
+失败阶段分为 `structural`、`compile` 和 `schema`。批量输入相互独立，
+后一条表达式不能引用同批前一条表达式新建的别名。依赖实际数据值、
+只在物化时出现的错误不属于该 API 的检查范围。
+
 ## 窗口配置
 
 CodeStr 使用 `partition_by`（实体分组轴）和 `order_by`（时间排序轴）控制窗口算子：

{codestr-0.3.0 → codestr-0.3.2}/README.md

@@ -40,12 +40,13 @@ result = cs.sql(
 print(result)
 ```
 
-## 两种 API 模式
+## API 模式
 
 | 模式 | API | 行为 |
 |------|-----|------|
 | **纯编译** | `cs.compile(expr) -> pl.Expr` | 无副作用，返回 Polars 表达式 |
 | **交互式** | `cs.sql(expr, lazy=False) -> pl.DataFrame` | 有状态，自动缓存与复用 |
+| **静态验证** | `cs.validate_expr(*exprs) -> list[dict]` | 无副作用，按当前 schema 干编译 |
 
 ```python
 # 纯编译 — 表达式可被任意 DataFrame 消费
@@ -57,6 +58,24 @@ cs.sql("close + volume as total")
 cs.sql("ts_mean(total, 5) as total_ma5")  # 复用上一步的 total
 ```
 
+### 静态验证
+
+`validate_expr()` 复用 `sql()` 的 planner，在当前 LazyFrame schema 上解析
+UDF、列引用、类型兼容性和混合窗口，但只调用 `collect_schema()`，不会
+`collect()` 数据或修改引擎缓存：
+
+```python
+results = cs.validate_expr(
+    "sin(1.0) as invalid",
+    "ts_mean(cs_moderate(close), 5) as factor",
+)
+```
+
+每个结果包含 `expr`、`valid`、`stage`、`error_type` 和 `message`。
+失败阶段分为 `structural`、`compile` 和 `schema`。批量输入相互独立，
+后一条表达式不能引用同批前一条表达式新建的别名。依赖实际数据值、
+只在物化时出现的错误不属于该 API 的检查范围。
+
 ## 窗口配置
 
 CodeStr 使用 `partition_by`（实体分组轴）和 `order_by`（时间排序轴）控制窗口算子：

{codestr-0.3.0 → codestr-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codestr"
-version = "0.3.0"
+version = "0.3.2"
 description = "DSL → Polars Expr compile engine for quantitative factor mining"
 readme = "README.md"
 license = {text = "MIT"}
@@ -23,7 +23,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-    "polars>=1.42.1",
+    "polars>=1.44.1",
     "lark>=1.0,<2.0",
     "loguru>=0.7,<1.0",
     "toolz>=1.0,<2.0",

{codestr-0.3.0 → codestr-0.3.2}/src/codestr/engine.py

@@ -195,6 +195,124 @@ class CodeStr:
         result["valid"] = len(result["reasons"]) == 0
         return result
 
+    def validate_expr(self, *exprs: str) -> list[dict[str, object]]:
+        """Dry-compile expressions against the current Polars schema.
+
+        Unlike :meth:`check_expr`, this resolves UDFs, planner stages, and
+        column/type compatibility. It never collects data or mutates engine
+        state. Batch expressions are validated independently.
+
+        Returns:
+            One result per input expression. ``stage`` is ``structural``,
+            ``compile``, or ``schema``; successful validation reaches the
+            ``schema`` stage with no error details.
+        """
+        base = self._data_ if self._data_ is not None else self.data.lazy()
+        registry = UDFRegistry.get_instance()
+        results = []
+
+        for expr in exprs:
+            try:
+                node = _parse(expr)
+            except Exception as error:
+                results.append(
+                    {
+                        "expr": expr,
+                        "valid": False,
+                        "stage": "structural",
+                        "error_type": type(error).__name__,
+                        "message": str(error),
+                    }
+                )
+                continue
+
+            structural = self.check_expr(expr)
+            if not structural["valid"]:
+                results.append(
+                    {
+                        "expr": expr,
+                        "valid": False,
+                        "stage": "structural",
+                        "error_type": "StructuralError",
+                        "message": "; ".join(structural["reasons"]),
+                    }
+                )
+                continue
+
+            try:
+                current_columns = base.collect_schema().names()
+            except Exception as error:
+                results.append(
+                    {
+                        "expr": expr,
+                        "valid": False,
+                        "stage": "schema",
+                        "error_type": type(error).__name__,
+                        "message": str(error),
+                    }
+                )
+                continue
+
+            try:
+                plan = build_execution_plan(
+                    node,
+                    registry,
+                    existing_columns=current_columns,
+                )
+                compiled_steps = [
+                    (
+                        _pure_compile(
+                            step.node,
+                            registry=registry,
+                            dims=getattr(self, "dims", None),
+                            ts_over=self._ts_over,
+                            cs_over=self._cs_over,
+                        ),
+                        step.output_name,
+                    )
+                    for step in plan.steps
+                ]
+            except Exception as error:
+                results.append(
+                    {
+                        "expr": expr,
+                        "valid": False,
+                        "stage": "compile",
+                        "error_type": type(error).__name__,
+                        "message": str(error),
+                    }
+                )
+                continue
+
+            try:
+                candidate = base
+                for compiled, output_name in compiled_steps:
+                    candidate = candidate.with_columns(compiled.alias(output_name))
+                    candidate.collect_schema()
+            except Exception as error:
+                results.append(
+                    {
+                        "expr": expr,
+                        "valid": False,
+                        "stage": "schema",
+                        "error_type": type(error).__name__,
+                        "message": str(error),
+                    }
+                )
+                continue
+
+            results.append(
+                {
+                    "expr": expr,
+                    "valid": True,
+                    "stage": "schema",
+                    "error_type": None,
+                    "message": None,
+                }
+            )
+
+        return results
+
     def _check_redundant(self, node: Call, reasons: list[str]):
         if not isinstance(node, Call):
             return

{codestr-0.3.0 → codestr-0.3.2}/src/codestr/udf/cs_udf.py

@@ -73,6 +73,7 @@ def cs_qcut(expr: pl.Expr, n_bins=10, partition_by=None, order_by=None):
     return (
         expr.qcut(n_bins, labels=[str(i) for i in range(1, n_bins + 1)], allow_duplicates=True)
         .over(partition_by=partition_by, order_by=order_by)
+        .cast(pl.String)
         .cast(pl.Int32)
     )
 

{codestr-0.3.0 → codestr-0.3.2}/tests/test_base_udf.py

@@ -6,6 +6,7 @@ import pytest
 
 from codestr.compiler import compile as ast_compile
 from codestr.syntax import Call, Column, Literal
+from codestr.udf import base_udf
 
 
 def _eval_expr(node, df: pl.DataFrame) -> pl.DataFrame:
@@ -84,6 +85,75 @@ class TestUnaryMath:
         result = df.select(ast_compile(node))["between(x, 2, 8)"].to_list()
         assert result == [False, True, False]
 
+    @pytest.mark.parametrize(
+        ("name", "value", "expected"),
+        [
+            ("cbrt", 8.0, 2.0),
+            ("sinh", 0.0, 0.0),
+            ("arcsin", 0.0, 0.0),
+            ("arcsinh", 0.0, 0.0),
+            ("cosh", 0.0, 1.0),
+            ("arccos", 1.0, 0.0),
+            ("arccosh", 1.0, 0.0),
+            ("tan", 0.0, 0.0),
+            ("tanh", 0.0, 0.0),
+            ("arctan", 0.0, 0.0),
+            ("arctanh", 0.0, 0.0),
+            ("cot", np.pi / 4, 1.0),
+            ("degrees", np.pi, 180.0),
+            ("log1p", np.e - 1, 1.0),
+        ],
+    )
+    def test_remaining_unary_numeric_contracts(self, name, value, expected):
+        df = pl.DataFrame({"x": [value]})
+        result = df.select(ast_compile(Call(name, (Column("x"),))))
+
+        assert result.item() == pytest.approx(expected)
+
+    def test_not(self):
+        df = pl.DataFrame({"x": [True, False]})
+
+        result = df.select(ast_compile(Call("not_", (Column("x"),))))
+
+        assert result.to_series().to_list() == [False, True]
+
+    def test_entropy(self):
+        df = pl.DataFrame({"x": [0.25, 0.75]})
+
+        result = df.select(ast_compile(Call("entropy", (Column("x"),))))
+
+        assert result.item() == pytest.approx(0.5623351446)
+
+    def test_trunc_closed_and_open_bounds(self):
+        df = pl.DataFrame({"x": [0.0, 1.0, 2.0]})
+        closed = base_udf.trunc(pl.col("x"), 0, 2)
+        opened = base_udf.trunc(pl.col("x"), 0, 2, left_closed=False, right_closed=False)
+
+        result = df.select(closed.alias("closed"), opened.alias("opened"))
+
+        assert result["closed"].to_list() == [0.0, 1.0, 2.0]
+        assert result["opened"].to_list() == [None, 1.0, None]
+
+    def test_cast_valid_and_invalid_dtype(self):
+        df = pl.DataFrame({"x": [1.5]})
+
+        result = df.select(base_udf.cast(pl.col("x"), "int"))
+
+        assert result.schema["x"] == pl.Int64
+        with pytest.raises(ValueError, match="not a valid type"):
+            base_udf.cast(pl.col("x"), "date")
+
+    def test_concat_and_null_type(self):
+        df = pl.DataFrame({"a": [1], "b": [2]})
+
+        result = df.select(
+            base_udf.concat(pl.col("a"), pl.col("b")).alias("values"),
+            base_udf.null_type(pl.col("a")).alias("null"),
+        )
+
+        assert result["values"].to_list() == [[1, 2]]
+        assert result["null"].to_list() == [None]
+
 
 class TestBinaryMath:
     def test_add(self):
@@ -116,6 +186,23 @@ class TestBinaryMath:
         node = Call("eq", (Column("a"), Column("b")))
         assert df.select(ast_compile(node))["(a==b)"].to_list() == [True, False]
 
+    @pytest.mark.parametrize(
+        ("name", "expected"),
+        [
+            ("floordiv", [2, 2]),
+            ("mod", [1, 1]),
+            ("lt", [False, False]),
+            ("le", [False, False]),
+            ("ge", [True, True]),
+            ("neq", [True, True]),
+        ],
+    )
+    def test_remaining_binary_contracts(self, name, expected):
+        df = pl.DataFrame({"a": [5, 7], "b": [2, 3]})
+        node = Call(name, (Column("a"), Column("b")))
+
+        assert df.select(ast_compile(node)).to_series().to_list() == expected
+
 
 class TestHorizontalOps:
     def test_max(self):
@@ -138,6 +225,17 @@ class TestHorizontalOps:
         node = Call("mean", (Column("a"), Column("b")))
         assert df.select(ast_compile(node))["mean(a, b)"].to_list() == [2.0, 4.0]
 
+    def test_arg_max_and_arg_min(self):
+        df = pl.DataFrame({"a": [1.0, 5.0], "b": [3.0, 2.0]})
+
+        result = df.select(
+            ast_compile(Call("arg_max", (Column("a"), Column("b")))).alias("max"),
+            ast_compile(Call("arg_min", (Column("a"), Column("b")))).alias("min"),
+        )
+
+        assert result["max"].to_list() == [1, 0]
+        assert result["min"].to_list() == [0, 1]
+
 
 class TestTernary:
     def test_if(self):

{codestr-0.3.0 → codestr-0.3.2}/tests/test_cs_udf.py

@@ -87,7 +87,9 @@ class TestCSQcut:
         node = Call("cs_qcut", (Column("x"), Literal(2)))
         expr = ast_compile(node)
         result = cs_df.select(expr)
-        assert result.height == 6
+
+        assert result.schema["cs_qcut(x, 2)"] == pl.Int32
+        assert result["cs_qcut(x, 2)"].to_list() == [1, 2, 1, 2, 2, 1]
 
 
 class TestCSMidby:
@@ -96,3 +98,41 @@ class TestCSMidby:
         expr = ast_compile(node)
         result = cs_df.select(expr)
         assert result.height == 6
+
+
+class TestRemainingCSOperators:
+    @pytest.mark.parametrize(
+        ("name", "expected_first"),
+        [
+            ("cs_ufit", 5.0),
+            ("cs_mid", 15.0),
+            ("cs_corr", 1.0),
+            ("cs_std", pytest.approx(7.0710678119)),
+            ("cs_var", 50.0),
+            ("cs_slope", 5.0),
+            ("cs_resid", 5.0),
+            ("cs_min", 10.0),
+            ("cs_peakmax", False),
+            ("cs_peakmin", False),
+        ],
+    )
+    def test_operator_values(self, cs_df, name, expected_first):
+        args = (
+            (Column("x"), Column("y"))
+            if name in {"cs_corr", "cs_slope", "cs_resid"}
+            else (Column("x"),)
+        )
+
+        result = cs_df.select(ast_compile(Call(name, args)))
+
+        assert result.item(0, 0) == expected_first
+
+    def test_cs_skew_executes_per_cross_section(self, cs_df):
+        result = cs_df.select(ast_compile(Call("cs_skew", (Column("x"),))))
+
+        assert result.height == cs_df.height
+
+    def test_cs_meanby_adds_grouping_columns(self, cs_df):
+        result = cs_df.select(ast_compile(Call("cs_meanby", (Column("x"), Column("asset")))))
+
+        assert result.to_series().to_list() == cs_df["x"].to_list()

{codestr-0.3.0 → codestr-0.3.2}/tests/test_engine.py

@@ -20,6 +20,12 @@ class TestCodeStrInit:
         assert cs.data is None
         assert "close" in cs.cache_columns
 
+    def test_init_collects_lazy_input_in_eager_mode(self, sample_df):
+        cs = CodeStr(sample_df.lazy())
+
+        assert isinstance(cs.data, pl.DataFrame)
+        assert cs.data.height == sample_df.height
+
     def test_init_invalid_data_raises(self):
         with pytest.raises(AssertionError):
             CodeStr([1, 2, 3])  # type: ignore
@@ -83,6 +89,17 @@ class TestSQLInteractiveMode:
         assert "total" in result.columns
         assert "spread" in result.columns
 
+    def test_same_query_reuses_expression_with_new_alias(self, sample_df):
+        cs = CodeStr(sample_df)
+
+        result = cs.sql(
+            "close + 1 as first",
+            "close + 1 as second",
+        )
+
+        assert cs.failed == []
+        assert result["first"].equals(result["second"])
+
     def test_sql_caching_reuses_expr(self, sample_df):
         """Subsequent identical expressions should reuse cached columns."""
         cs = CodeStr(sample_df)
@@ -441,6 +458,116 @@ class TestCheckExpr:
         assert result["reasons"] == []
 
 
+class TestValidateExpr:
+    def test_validates_expression_against_current_schema(self, sample_df):
+        cs = CodeStr(sample_df)
+
+        assert cs.validate_expr("ts_mean(close, 2) as mean_close") == [
+            {
+                "expr": "ts_mean(close, 2) as mean_close",
+                "valid": True,
+                "stage": "schema",
+                "error_type": None,
+                "message": None,
+            }
+        ]
+
+    def test_reports_structural_compile_and_schema_failures(self, sample_df):
+        cs = CodeStr(sample_df)
+
+        structural = cs.validate_expr("")[0]
+        compile_failure = cs.validate_expr("sin(1.0) as factor")[0]
+        schema_failure = cs.validate_expr("missing + 1 as factor")[0]
+
+        assert structural["valid"] is False
+        assert structural["stage"] == "structural"
+        assert structural["error_type"] == "ParseError"
+        assert structural["message"]
+        assert compile_failure["valid"] is False
+        assert compile_failure["stage"] == "compile"
+        assert compile_failure["error_type"] == "CompileError"
+        assert "sin" in compile_failure["message"]
+        assert schema_failure["valid"] is False
+        assert schema_failure["stage"] == "schema"
+        assert schema_failure["error_type"] == "ColumnNotFoundError"
+        assert "missing" in schema_failure["message"]
+
+    def test_reports_non_parse_structural_failure(self, sample_df):
+        cs = CodeStr(sample_df)
+
+        result = cs.validate_expr("close - close as invalid")[0]
+
+        assert result["valid"] is False
+        assert result["stage"] == "structural"
+        assert result["error_type"] == "StructuralError"
+        assert "redundant:sub" in result["message"]
+
+    def test_reports_invalid_base_lazy_schema(self):
+        invalid = pl.DataFrame({"x": [1.0]}).lazy().select("missing")
+        cs = CodeStr(invalid, pure_lazy=True)
+
+        result = cs.validate_expr("x + 1 as factor")[0]
+
+        assert result["valid"] is False
+        assert result["stage"] == "schema"
+        assert result["error_type"] == "ColumnNotFoundError"
+
+    def test_validates_mixed_window_through_planner(self, mixed_window_df):
+        cs = CodeStr(mixed_window_df, align=False)
+
+        result = cs.validate_expr("ts_mean(cs_moderate(x), 2, min_samples=1) as factor")
+
+        assert result[0]["valid"] is True
+        assert result[0]["stage"] == "schema"
+
+    def test_batch_expressions_are_independent(self, sample_df):
+        cs = CodeStr(sample_df)
+
+        results = cs.validate_expr(
+            "close * 2 as scaled",
+            "scaled + 1 as shifted",
+        )
+
+        assert results[0]["valid"] is True
+        assert results[1]["valid"] is False
+        assert results[1]["stage"] == "schema"
+
+    def test_does_not_collect_or_mutate_engine_state(self, sample_df):
+        cs = CodeStr(sample_df)
+        cs.sql("close + 1 as cached")
+
+        def raise_during_collect(value):
+            raise ValueError("must not collect")
+
+        def lazy_only(expr):
+            return expr.map_elements(
+                raise_during_collect,
+                return_dtype=pl.Float64,
+            )
+
+        cs.register_udf(lazy_only)
+        state = {
+            "data": cs.data,
+            "lazy": cs._data_,
+            "expr_cache": dict(cs._expr_cache),
+            "cur_expr_cache": dict(cs._cur_expr_cache),
+            "internal_columns": set(cs._internal_columns),
+            "last_query_cache": cs._last_query_cache,
+            "failed": list(cs.failed),
+        }
+
+        result = cs.validate_expr("lazy_only(close) as validated")
+
+        assert result[0]["valid"] is True
+        assert cs.data is state["data"]
+        assert cs._data_ is state["lazy"]
+        assert cs._expr_cache == state["expr_cache"]
+        assert cs._cur_expr_cache == state["cur_expr_cache"]
+        assert cs._internal_columns == state["internal_columns"]
+        assert cs._last_query_cache is state["last_query_cache"]
+        assert cs.failed == state["failed"]
+
+
 class TestClearCache:
     def test_clear_cache_resets_state(self, sample_df):
         cs = CodeStr(sample_df)

{codestr-0.3.0 → codestr-0.3.2}/uv.lock

@@ -51,7 +51,7 @@ wheels = [
 
 [[package]]
 name = "codestr"
-version = "0.3.0"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "lark" },
@@ -81,7 +81,7 @@ requires-dist = [
     { name = "loguru", specifier = ">=0.7,<1.0" },
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.10" },
     { name = "numpy", specifier = ">=1.26,<3.0" },
-    { name = "polars", specifier = ">=1.42.1" },
+    { name = "polars", specifier = ">=1.44.1" },
     { name = "pytest", marker = "extra == 'test'", specifier = ">=8.0" },
     { name = "pytest-cov", marker = "extra == 'test'", specifier = ">=5.0" },
     { name = "toolz", specifier = ">=1.0,<2.0" },
@@ -630,30 +630,30 @@ wheels = [
 
 [[package]]
 name = "polars"
-version = "1.42.1"
+version = "1.44.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "polars-runtime-32" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/27/99/fe77f10a13a778705ef05b499fc708c9a0b0a3680d9eb6bc6e1b6a6b9914/polars-1.42.1.tar.gz", hash = "sha256:2fe94f3059334650bd850ae19a9c165dcd5d9cb12cd95ea04de2201662e70e8a", size = 741532, upload-time = "2026-06-30T04:57:51.504Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/73/258a1fe17bb2744a507199566ed712663144fdd0811b615b59a47dfa38d2/polars-1.44.1.tar.gz", hash = "sha256:ef3c89e9ebbbe8eb343c06873f1945683f8b6f97a1bdf001c60551c6c5e3cda1", size = 765660, upload-time = "2026-08-26T07:09:12.704Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/6a/edd939cc6fa04b6415aaa9bf19720fc74ead81234b3d38542e0005816d4d/polars-1.42.1-py3-none-any.whl", hash = "sha256:3c0c65cdfa21a621650c4bdcbbccf93964d052fd766c3e70e84a55d961c259fd", size = 837622, upload-time = "2026-06-30T04:56:34.686Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/f1/59154659081930fbde291ea6225607956b500a71b0ce45d88217b7d32da2/polars-1.44.1-py3-none-any.whl", hash = "sha256:1fa62fc1c88fba77a68b28291b5aabdd69e5f38b34e59721a064ae3169b59bb5", size = 865208, upload-time = "2026-08-26T07:07:44.646Z" },
 ]
 
 [[package]]
 name = "polars-runtime-32"
-version = "1.42.1"
+version = "1.44.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1f/59/15bcc4dac380c6d63efa5446d8317f22671cbd6c9dadd576bd17a334c45a/polars_runtime_32-1.42.1.tar.gz", hash = "sha256:4d4809e1c1b9a6611f6944f27b24abea902b5159e6b6fa262fd716e947af5afd", size = 3045460, upload-time = "2026-06-30T04:57:52.866Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/b2/2a76415d047a45df05489f2334c91ff120a274cf655d4ca030c7f54a8743/polars_runtime_32-1.44.1.tar.gz", hash = "sha256:abd10a54ed1caff42228610fcba0f93251f9870bd7cffb0c78bc26f5e0718ce4", size = 3171156, upload-time = "2026-08-26T07:09:14.243Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/62/29/16ff6e4e91d71e530d3581f45e342a9cc35072ac6b31dcbc2fa33de2569e/polars_runtime_32-1.42.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:bbdc26d68ee5b23b0ce227fa0599220aa35b77c826b6b0a6b2d8e7f6c1c36974", size = 53117325, upload-time = "2026-06-30T04:56:37.972Z" },
-    { url = "https://files.pythonhosted.org/packages/04/8e/4f8296fcfd1347f1351342fecf13bf2430d7efbae2f1f45964ec7930a99e/polars_runtime_32-1.42.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:f6c0288be940b607dc4a7476c01e67fb6bbee93f5f1dd42c64970274c71008ba", size = 47446251, upload-time = "2026-06-30T04:56:41.459Z" },
-    { url = "https://files.pythonhosted.org/packages/88/2e/0d66a7deadc453b890c3391034ca8ab4b05d0beaebbb92a7d65199fba61b/polars_runtime_32-1.42.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:635d9dbcae2302ae223afb395d5cd220bffa61a53d0ab6871d17c8bc830101cf", size = 51359402, upload-time = "2026-06-30T04:56:44.595Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/10/ffb85fa380bc9c9000dc35f40f44954dde49023018501c54faab94b3a39e/polars_runtime_32-1.42.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d059e8e53cc114ff82f9bd791fd341dc53534a2c745e6f6aa37594c3a93f01fe", size = 57302723, upload-time = "2026-06-30T04:56:47.609Z" },
-    { url = "https://files.pythonhosted.org/packages/c2/63/ca50adc62e44224ca5c622a842ba6f35ee87d1d40ef0df7ea2ed6c6edb08/polars_runtime_32-1.42.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f91f0b13588324905682809d270e1de5f1990c908721c8527657d77a044c9919", size = 51515673, upload-time = "2026-06-30T04:56:50.88Z" },
-    { url = "https://files.pythonhosted.org/packages/63/c3/08fbbf38deaa17bf34a601d327cb7451074098673c78b7c1a8538dde9794/polars_runtime_32-1.42.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8b8bf972d99d48aaaa2582e2bce966a6f43bc815bd8725d15f5cab9e2fb15d17", size = 55217259, upload-time = "2026-06-30T04:56:53.834Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/0e/51db89361668fe077a835fc579277f824ba526e7daf7b94d23d25439e0d0/polars_runtime_32-1.42.1-cp310-abi3-win_amd64.whl", hash = "sha256:e9364c26da389a8b7339e4d29e20a3d12af730247e6ed3b7804bddce2477f428", size = 52715432, upload-time = "2026-06-30T04:56:57.109Z" },
-    { url = "https://files.pythonhosted.org/packages/76/c5/2fb8592d691bd114de25d9c84300b23541dca7060eac11d7b4bed0327786/polars_runtime_32-1.42.1-cp310-abi3-win_arm64.whl", hash = "sha256:7051226e6b42ffc395a7a9190377cd28649fbfb991b8f85c6271f4e1cfb736fb", size = 46718300, upload-time = "2026-06-30T04:56:59.855Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/93/ef9344dcec16757cf21027dc907ef989197e50742cfe4407f2e87edb0a7f/polars_runtime_32-1.44.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:1dfccb2b52aa50468a7d28e3e61c8338a13fb5bffc8646e388a649f5bdc6b463", size = 53962370, upload-time = "2026-08-26T07:07:47.21Z" },
+    { url = "https://files.pythonhosted.org/packages/10/da/38b32b7901af33f1fee2172ceaa39e9159825657920064298917392d78fa/polars_runtime_32-1.44.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:0580807dc3eed258f0db70bb65d905dd43f0135392119ec25308033ae24258fb", size = 48620468, upload-time = "2026-08-26T07:07:50.436Z" },
+    { url = "https://files.pythonhosted.org/packages/49/51/185af877d1d2236671493cf72bd3327a6046240eeea69c0696d1af2a5acb/polars_runtime_32-1.44.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0627f9aa82cb869725235e5188f698862fd9ada0c8c1cf65c3dc5a49a4a0ec26", size = 52455947, upload-time = "2026-08-26T07:07:53.776Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/0a/0858f60cb5a6f8f73ec4cdd73eccd9f748d66bfc23304c5c23fa3468094a/polars_runtime_32-1.44.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eea4283be8e60822d890dbda20588fe59b4172b508bd5ebf3471e531ca9f50d7", size = 58561262, upload-time = "2026-08-26T07:07:57.508Z" },
+    { url = "https://files.pythonhosted.org/packages/73/08/de4774b5612d7c8739f89ac01b601486b4f057b1da35a5b876bf9276fd95/polars_runtime_32-1.44.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:04e2c0f46e7a9906fffb1897f18f23b079b74f83c56b50060bace9e7b9b49b1a", size = 52636064, upload-time = "2026-08-26T07:08:06.337Z" },
+    { url = "https://files.pythonhosted.org/packages/98/ac/769c598dd106e2a6647798da3ed25ddeee67f2d12c04f5da316cb3da6360/polars_runtime_32-1.44.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:0956f0cae632d8fad3a04b4315bf2bb69b56d10c83c79a75c2c4c5a13b9ce5cc", size = 56447612, upload-time = "2026-08-26T07:08:12.36Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/ee/98408296e15388020b6183323fdbe78ccab4f72c20d8e0d7092c062d3ad2/polars_runtime_32-1.44.1-cp310-abi3-win_amd64.whl", hash = "sha256:159334184e6fbb074c9f4692221ea19970a5e2bed2a479f9d7bdb00b7f3eedb9", size = 53702970, upload-time = "2026-08-26T07:08:15.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9d/8b17e075aac73c881a50b6c1f690d20df46db2f3bcabc99f600ecdee1290/polars_runtime_32-1.44.1-cp310-abi3-win_arm64.whl", hash = "sha256:3ba28d638d0513e0b4afbcdab5c0059a85021e5f81d62b5f793e7e23badb2cf7", size = 47281050, upload-time = "2026-08-26T07:08:18.43Z" },
 ]
 
 [[package]]