sqlglotc 30.0.2__tar.gz → 30.1.0__tar.gz

{sqlglotc-30.0.2/sqlglotc.egg-info → sqlglotc-30.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlglotc
-Version: 30.0.2
+Version: 30.1.0
 Summary: mypyc-compiled extensions for sqlglot
 Author-email: Toby Mao <toby.mao@gmail.com>
 License-Expression: MIT

{sqlglotc-30.0.2 → sqlglotc-30.1.0}/pyproject.toml

@@ -14,7 +14,7 @@ Homepage = "https://sqlglot.com/"
 Repository = "https://github.com/tobymao/sqlglot"
 
 [build-system]
-requires = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy>=1.19.1.post1", "types-python-dateutil"]
+requires = ["setuptools >= 61.0", "setuptools_scm", "sqlglot-mypy>=1.19.1.post1", "types-python-dateutil", "sqlglot"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools]
@@ -25,10 +25,6 @@ root = ".."
 fallback_version = "0.0.0"
 local_scheme = "no-local-version"
 
-[tool.mypy]
-# Allow mypyc to resolve sqlglot.* from the repo root (../sqlglot/) or sdist root (./sqlglot/).
-mypy_path = [".", ".."]
-
 [[tool.mypy.overrides]]
-module = "sqlglot._version"
+module = ["sqlglot._version", "sqlglotc"]
 ignore_missing_imports = true

sqlglotc-30.1.0/setup.py

@@ -0,0 +1,132 @@
+import os
+import shutil
+
+from setuptools import setup
+from setuptools.command.build_ext import build_ext as _build_ext
+from setuptools.command.sdist import sdist as _sdist
+from mypyc.build import mypycify
+
+SQLGLOT_SRC = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "sqlglot")
+
+
+def _find_sqlglot_dir():
+    """Find the sqlglot source directory: repo source, or installed package.
+
+    When the installed package is in site-packages, copy it to a clean temp
+    directory so mypy doesn't discover unrelated modules (mypy_extensions,
+    typing_extensions) that cause shadowing errors.
+    """
+    if os.path.isdir(SQLGLOT_SRC):
+        return SQLGLOT_SRC
+
+    # Fall back to the installed sqlglot package (build dependency).
+    import sqlglot
+    import tempfile
+
+    installed = os.path.dirname(sqlglot.__file__)
+    tmp = tempfile.mkdtemp(prefix="sqlglotc_build_")
+    dst = os.path.join(tmp, "sqlglot")
+    shutil.copytree(installed, dst)
+    return dst
+
+
+def _subpkg_files(src_dir, subpkg, files=None):
+    """List source files from a sqlglot subpackage. Compiles all .py files if `files` is None."""
+    if files is None:
+        files = sorted(
+            f
+            for f in os.listdir(os.path.join(src_dir, subpkg))
+            if f.endswith(".py") and f != "__init__.py"
+        )
+    return [os.path.join(subpkg, f) for f in files]
+
+
+def _source_files(src_dir):
+    return [
+        "errors.py",
+        "generator.py",
+        "helper.py",
+        "parser.py",
+        "schema.py",
+        "serde.py",
+        "time.py",
+        "tokenizer_core.py",
+        "trie.py",
+        *_subpkg_files(src_dir, "expressions"),
+        *_subpkg_files(src_dir, "generators"),
+        *_subpkg_files(
+            src_dir,
+            "optimizer",
+            [
+                "scope.py",
+                "resolver.py",
+                "isolate_table_selects.py",
+                "normalize_identifiers.py",
+                "qualify.py",
+                "qualify_tables.py",
+                "qualify_columns.py",
+            ],
+        ),
+        *_subpkg_files(src_dir, "parsers"),
+        *_subpkg_files(src_dir, "executor", ["table.py"]),
+    ]
+
+
+SRC_DIR = _find_sqlglot_dir()
+SOURCE_FILES = _source_files(SRC_DIR)
+
+# Set MYPYPATH to the parent of the sqlglot source so mypy resolves
+# `import sqlglot` from there — not from site-packages where
+# mypy_extensions.py / typing_extensions.py can cause shadowing errors.
+os.environ["MYPYPATH"] = os.path.dirname(SRC_DIR)
+
+
+def _source_paths():
+    return [os.path.join(SRC_DIR, f) for f in SOURCE_FILES]
+
+
+class build_ext(_build_ext):
+    def copy_extensions_to_source(self):
+        """For editable installs, put sqlglot.* .so files in the sqlglot source dir."""
+        for ext in self.extensions:
+            fullname = self.get_ext_fullname(ext.name)
+            filename = self.get_ext_filename(fullname)
+            src = os.path.join(self.build_lib, filename)
+            parts = fullname.split(".")
+            if parts[0] == "sqlglot" and os.path.isdir(SQLGLOT_SRC):
+                # Place compiled sqlglot.* / sqlglot.sub.* modules in the sqlglot source tree.
+                sub_module = ".".join(parts[1:])
+                dst = os.path.join(SQLGLOT_SRC, self.get_ext_filename(sub_module))
+            else:
+                # Place the mypyc runtime helper (e.g., HASH__mypyc) inside sqlglot/.
+                # sqlglot/__init__.py bootstraps it into sys.modules for editable installs.
+                dst = os.path.join(SQLGLOT_SRC, os.path.basename(filename))
+            self.copy_file(src, dst, level=self.verbose)
+
+
+class sdist(_sdist):
+    """Bundle sqlglot source files into the sdist as a fallback."""
+
+    def run(self):
+        local_sqlglot = os.path.join(os.path.dirname(os.path.abspath(__file__)), "sqlglot")
+        os.makedirs(local_sqlglot, exist_ok=True)
+        subpkgs = {os.path.dirname(f) for f in SOURCE_FILES if os.path.dirname(f)}
+        for subpkg in subpkgs:
+            pkg_dir = os.path.join(local_sqlglot, subpkg)
+            os.makedirs(pkg_dir, exist_ok=True)
+        for fname in SOURCE_FILES:
+            dst_path = os.path.join(local_sqlglot, fname)
+            os.makedirs(os.path.dirname(dst_path), exist_ok=True)
+            shutil.copy2(os.path.join(SQLGLOT_SRC, fname), dst_path)
+        try:
+            super().run()
+        finally:
+            shutil.rmtree(local_sqlglot, ignore_errors=True)
+
+
+setup(
+    name="sqlglotc",
+    packages=[],
+    ext_modules=mypycify(_source_paths(), opt_level=os.environ.get("MYPYC_OPT", "2")),
+    cmdclass={"build_ext": build_ext, "sdist": sdist},
+)

{sqlglotc-30.0.2 → sqlglotc-30.1.0}/sqlglot/errors.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import typing as t
 from enum import auto
-
+from collections.abc import Sequence
 from sqlglot.helper import AutoName
 
 
@@ -150,7 +150,7 @@ def highlight_sql(
     return formatted_sql, start_context, highlight, end_context
 
 
-def concat_messages(errors: t.Sequence[t.Any], maximum: int) -> str:
+def concat_messages(errors: Sequence[t.Any], maximum: int) -> str:
     msg = [str(e) for e in errors[:maximum]]
     remaining = len(errors) - maximum
     if remaining > 0:
@@ -158,5 +158,5 @@ def concat_messages(errors: t.Sequence[t.Any], maximum: int) -> str:
     return "\n\n".join(msg)
 
 
-def merge_errors(errors: t.Sequence[ParseError]) -> t.List[t.Dict[str, t.Any]]:
+def merge_errors(errors: Sequence[ParseError]) -> list[dict[str, t.Any]]:
     return [e_dict for error in errors for e_dict in error.errors]

{sqlglotc-30.0.2 → sqlglotc-30.1.0}/sqlglot/expressions/builders.py

@@ -50,13 +50,14 @@ from sqlglot.expressions.functions import Case, Cast
 from sqlglot.expressions.array import Array
 
 if t.TYPE_CHECKING:
+    from collections.abc import Sequence, Iterable
     from sqlglot.dialects.dialect import DialectType
     from sqlglot.expressions.core import ExpOrStr, Func
     from sqlglot.expressions.datatypes import DATA_TYPE
     from sqlglot.expressions.query import Query
 
 
-def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
+def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts: t.Any) -> Select:
     """
     Initializes a syntax tree from one or multiple SELECT expressions.
 
@@ -78,7 +79,7 @@ def select(*expressions: ExpOrStr, dialect: DialectType = None, **opts) -> Selec
     return Select().select(*expressions, dialect=dialect, **opts)
 
 
-def from_(expression: ExpOrStr, dialect: DialectType = None, **opts) -> Select:
+def from_(expression: ExpOrStr, dialect: DialectType = None, **opts: t.Any) -> Select:
     """
     Initializes a syntax tree from a FROM expression.
 
@@ -105,9 +106,9 @@ def update(
     properties: t.Optional[dict] = None,
     where: t.Optional[ExpOrStr] = None,
     from_: t.Optional[ExpOrStr] = None,
-    with_: t.Optional[t.Dict[str, ExpOrStr]] = None,
+    with_: t.Optional[dict[str, ExpOrStr]] = None,
     dialect: DialectType = None,
-    **opts,
+    **opts: t.Any,
 ) -> Update:
     """
     Creates an update statement.
@@ -166,7 +167,7 @@ def delete(
     where: t.Optional[ExpOrStr] = None,
     returning: t.Optional[ExpOrStr] = None,
     dialect: DialectType = None,
-    **opts,
+    **opts: t.Any,
 ) -> Delete:
     """
     Builds a delete statement.
@@ -195,12 +196,12 @@ def delete(
 def insert(
     expression: ExpOrStr,
     into: ExpOrStr,
-    columns: t.Optional[t.Sequence[str | Identifier]] = None,
+    columns: t.Optional[Sequence[str | Identifier]] = None,
     overwrite: t.Optional[bool] = None,
     returning: t.Optional[ExpOrStr] = None,
     dialect: DialectType = None,
     copy: bool = True,
-    **opts,
+    **opts: t.Any,
 ) -> Insert:
     """
     Builds an INSERT statement.
@@ -244,7 +245,7 @@ def merge(
     returning: t.Optional[ExpOrStr] = None,
     dialect: DialectType = None,
     copy: bool = True,
-    **opts,
+    **opts: t.Any,
 ) -> Merge:
     """
     Builds a MERGE statement.
@@ -408,7 +409,7 @@ def subquery(
     expression: ExpOrStr,
     alias: t.Optional[Identifier | str] = None,
     dialect: DialectType = None,
-    **opts,
+    **opts: t.Any,
 ) -> Select:
     """
     Build a subquery expression that's selected from.
@@ -433,7 +434,11 @@ def subquery(
 
 
 def cast(
-    expression: ExpOrStr, to: DATA_TYPE, copy: bool = True, dialect: DialectType = None, **opts
+    expression: ExpOrStr,
+    to: DATA_TYPE,
+    copy: bool = True,
+    dialect: DialectType = None,
+    **opts: t.Any,
 ) -> Cast:
     """Cast an expression to a data type.
 
@@ -512,9 +517,9 @@ def table_(
 
 
 def values(
-    values: t.Iterable[t.Tuple[object, ...] | Tuple],
+    values: Iterable[tuple[object, ...] | Tuple],
     alias: t.Optional[str] = None,
-    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
+    columns: t.Optional[Iterable[str] | dict[str, DataType]] = None,
 ) -> Values:
     """Build VALUES statement.
 
@@ -962,7 +967,7 @@ def func(name: str, *args, copy: bool = True, dialect: DialectType = None, **kwa
 
 def case(
     expression: t.Optional[ExpOrStr] = None,
-    **opts,
+    **opts: t.Any,
 ) -> Case:
     """
     Initialize a CASE statement.