pandas-query-sql 0.8.1__tar.gz → 0.8.3.dev0__tar.gz

{pandas_query_sql-0.8.1 → pandas_query_sql-0.8.3.dev0}/PKG-INFO

@@ -1,26 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pandas_query_sql
-Version: 0.8.1
+Version: 0.8.3.dev0
 Summary: sqldf for pandas
-Author-Email: Alexander Plavin <alexander@plav.in>, Greg Lamp <lamp.greg@gmail.com>, Michael Dempsey <bluestealth@bluestealth.pw>
-License: MIT
-Classifier: License :: OSI Approved :: MIT License
-Project-URL: Homepage, https://github.com/bluestealth/pandasql/
-Requires-Python: >=3.8
+Author: Alexander Plavin, Greg Lamp, Michael Dempsey
+Author-email: Alexander Plavin <alexander@plav.in>, Greg Lamp <lamp.greg@gmail.com>, Michael Dempsey <bluestealth@bluestealth.pw>
+License-Expression: MIT
+License-File: LICENSE.txt
 Requires-Dist: numpy
 Requires-Dist: packaging
 Requires-Dist: pandas
 Requires-Dist: sqlalchemy
-Requires-Dist: psycopg2; extra == "postgresql"
-Requires-Dist: psycopg2-binary; extra == "postgresql-binary"
-Requires-Dist: black; extra == "linters"
-Requires-Dist: ruff; extra == "linters"
-Requires-Dist: pytest; extra == "testing"
-Requires-Dist: psycopg2-binary; extra == "testing"
+Requires-Dist: psycopg2 ; extra == 'postgresql'
+Requires-Dist: psycopg2-binary ; extra == 'postgresql-binary'
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/bluestealth/pandasql/
 Provides-Extra: postgresql
 Provides-Extra: postgresql-binary
-Provides-Extra: linters
-Provides-Extra: testing
 Description-Content-Type: text/markdown
 
 pandasql

{pandas_query_sql-0.8.1 → pandas_query_sql-0.8.3.dev0}/pyproject.toml

@@ -1,77 +1,65 @@
 [project]
 name = "pandas_query_sql"
-version = "0.8.1"
+version = "0.8.3.dev0"
 description = "sqldf for pandas"
-authors = [
-    { name = "Alexander Plavin", email = "alexander@plav.in" },
-    { name = "Greg Lamp", email = "lamp.greg@gmail.com" },
-    { name = "Michael Dempsey", email = "bluestealth@bluestealth.pw" },
-]
 dependencies = [
     "numpy",
     "packaging",
     "pandas",
     "sqlalchemy",
 ]
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 readme = "README.md"
-classifiers = [
-    "License :: OSI Approved :: MIT License",
-]
+license = "MIT"
+license-files = ["LICENSE.txt"]
+
+[[project.authors]]
+name = "Alexander Plavin"
+email = "alexander@plav.in"
 
-[project.license]
-text = "MIT"
+[[project.authors]]
+name = "Greg Lamp"
+email = "lamp.greg@gmail.com"
+
+[[project.authors]]
+name = "Michael Dempsey"
+email = "bluestealth@bluestealth.pw"
 
 [project.urls]
 Homepage = "https://github.com/bluestealth/pandasql/"
 
 [project.optional-dependencies]
-postgresql = [
-    "psycopg2",
-]
-postgresql-binary = [
-    "psycopg2-binary",
-]
-linters = [
-    "black",
+postgresql = ["psycopg2"]
+postgresql-binary = ["psycopg2-binary"]
+
+[dependency-groups]
+dev = [
     "ruff",
-]
-testing = [
     "pytest",
     "psycopg2-binary",
+    "testcontainers[postgres]",
+    "ty",
 ]
 
 [build-system]
-requires = [
-    "pdm-backend",
-]
-build-backend = "pdm.backend"
-
-[tool.pdm]
-distribution = true
+requires = ["uv_build>=0.13.5,<0.14"]
+build-backend = "uv_build"
 
-[tool.pdm.package-dir]
-pandasql = "pandasql"
+[tool.uv.build-backend]
+module-name = "pandasql"
 
-[tool.setuptools.package-data]
-pandasql = [
-    "data/births.csv",
-    "data/birth_by_months.csv",
-    "data/meat.csv",
-    "py.typed",
-]
+[tool.ty.src]
+exclude = ["examples/**"]
 
 [tool.ruff]
 line-length = 120
-target-version = "py38"
+target-version = "py311"
 
 [tool.ruff.lint]
-select = [
-    "ALL",
-]
+select = ["ALL"]
 ignore = [
-    "FA100",
-    "ANN101",
+    "COM812",
+    "CPY001",
     "FBT001",
     "FBT002",
     "TRY003",
@@ -92,21 +80,18 @@ max-complexity = 14
 convention = "google"
 
 [tool.ruff.lint.per-file-ignores]
-"src/pandasql/__init__.py" = [
-    "D",
-]
+"src/pandasql/__init__.py" = ["D"]
 "examples/**/*.py" = [
     "D",
     "INP001",
 ]
 "tests/**/*.py" = [
     "D",
+    "BLE001",
 ]
 
 [tool.ruff.lint.extend-per-file-ignores]
-"examples/**/*.py" = [
-    "T",
-]
+"examples/**/*.py" = ["T"]
 "tests/**/*.py" = [
     "T",
     "S101",

pandas_query_sql-0.8.3.dev0/pyproject.toml.orig

@@ -0,0 +1,74 @@
+[project]
+name = "pandas_query_sql"
+version = "0.8.3.dev0"
+description = "sqldf for pandas"
+authors = [
+    {name = "Alexander Plavin", email = "alexander@plav.in"},
+    {name = "Greg Lamp", email= "lamp.greg@gmail.com"},
+    {name = "Michael Dempsey", email = "bluestealth@bluestealth.pw"},
+]
+dependencies = [
+    "numpy",
+    "packaging",
+    "pandas",
+    "sqlalchemy",
+]
+requires-python = ">=3.11"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE.txt"]
+
+[project.urls]
+Homepage = "https://github.com/bluestealth/pandasql/"
+
+[project.optional-dependencies]
+postgresql = [
+    "psycopg2",
+]
+postgresql-binary = [
+    "psycopg2-binary",
+]
+
+[dependency-groups]
+dev = [
+    "ruff",
+    "pytest",
+    "psycopg2-binary",
+    "testcontainers[postgres]",
+    'ty',
+]
+
+[build-system]
+requires = ["uv_build>=0.13.5,<0.14"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "pandasql"
+
+[tool.ty.src]
+exclude = ["examples/**"]
+
+[tool.ruff]
+line-length = 120
+target-version = 'py311'
+
+[tool.ruff.lint]
+select = ['ALL']
+ignore = ['COM812', "CPY001", 'FBT001', 'FBT002', 'TRY003', 'EM101', 'PLR2004', 'N818']
+flake8-quotes = {}
+isort = { known-first-party = [] }
+mccabe = { max-complexity = 14 }
+pydocstyle = { convention = 'google' }
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.ruff.lint.per-file-ignores]
+'src/pandasql/__init__.py' = ['D']
+"examples/**/*.py" = ['D', 'INP001']
+"tests/**/*.py" = ['D', 'BLE001']
+
+[tool.ruff.lint.extend-per-file-ignores]
+"examples/**/*.py" = ['T']
+"tests/**/*.py" = ['T', 'S101', 'PD901', 'PLR']

{pandas_query_sql-0.8.1 → pandas_query_sql-0.8.3.dev0}/src/pandasql/sqldf.py

@@ -4,17 +4,20 @@ import importlib.metadata
 import inspect
 import re
 import sqlite3
+from collections.abc import Generator
 from contextlib import contextmanager
-from typing import Any, Dict, Iterator, Optional, Set, Union
+from typing import Any
 from warnings import catch_warnings, filterwarnings
 
 import packaging.version
 from pandas import DataFrame
+from pandas.errors import DatabaseError as PandasDatabaseError
 from pandas.io.sql import read_sql_query
 from sqlalchemy import create_engine  # pyright: ignore[reportUnknownVariableType]
 from sqlalchemy.engine import Connection, Engine
 from sqlalchemy.event import listen  # pyright: ignore[reportUnknownVariableType]
-from sqlalchemy.exc import DatabaseError, ResourceClosedError
+from sqlalchemy.exc import DatabaseError as SQLAlchemyDatabaseError
+from sqlalchemy.exc import ResourceClosedError
 from sqlalchemy.pool import NullPool
 from sqlalchemy.pool.base import (
     _ConnectionRecord,  # pyright: ignore[reportPrivateUsage]
@@ -40,7 +43,7 @@ class PandaSQL:
         loaded_tables: set of currently loaded table names
     """
 
-    def __init__(self, db_uri: Optional[str], persist: bool = False) -> None:
+    def __init__(self, db_uri: str | None, persist: bool = False) -> None:
         """Initialize with a specific database.
 
         :param db_uri: SQLAlchemy-compatible database URI.
@@ -61,7 +64,7 @@ class PandaSQL:
             )
 
         self.persist = persist
-        self.loaded_tables: Set[str] = set()
+        self.loaded_tables: set[str] = set()
         if self.persist:
             self._conn = self.engine.connect()
             self._init_connection(self._conn)
@@ -69,8 +72,8 @@ class PandaSQL:
     def __call__(
         self,
         query: str,
-        env: Optional[Dict[str, Any]] = None,
-    ) -> Optional[DataFrame]:
+        env: dict[str, Any] | None = None,
+    ) -> DataFrame | None:
         """Execute the SQL query.
 
         Automatically creates tables mentioned in the query from dataframes before executing.
@@ -96,17 +99,17 @@ class PandaSQL:
 
             try:
                 result = read_sql_query(sql=query, con=conn)
-            except DatabaseError as ex:
-                raise PandaSQLException(ex) from ex
             except ResourceClosedError:
                 # query returns nothing
                 result = None
+            except (SQLAlchemyDatabaseError, PandasDatabaseError) as ex:
+                raise PandaSQLException(ex) from ex
 
         return result
 
     @property
     @contextmanager
-    def conn(self) -> Iterator[Connection]:
+    def conn(self) -> Generator[Connection]:
         """Context Manager for database connection."""
         if self.persist:
             # the connection is created in __init__, so just return it
@@ -125,13 +128,13 @@ class PandaSQL:
     def _init_connection(self, conn: Connection) -> None:
         if self.engine.name == "postgresql":
             if SQLALCHEMY_MAJOR_VERSION >= 2:
-                from sqlalchemy import text
+                from sqlalchemy import text  # noqa: PLC0415
 
                 conn.execute(  # pyright: ignore[reportUnknownMemberType]
                     statement=text("set search_path to pg_temp"),
                 )
             else:
-                conn.execute(  # pyright: ignore[reportUnknownMemberType]
+                conn.execute(  # ty: ignore[no-matching-overload]
                     statement="set search_path to pg_temp",
                 )
 
@@ -143,26 +146,22 @@ class PandaSQL:
         dbapi_conn.text_factory = str
 
 
-def get_outer_frame_variables() -> Dict[str, Any]:
+def get_outer_frame_variables() -> dict[str, Any]:
     """Get a dict of local and global variables of the first outer frame from another file."""
     frame = inspect.currentframe()
-    variables: Dict[str, Any] = {}
+    variables: dict[str, Any] = {}
 
     if not frame:
         return variables
 
     cur_filename = inspect.getframeinfo(frame).filename
-    outer_frame = next(
-        f
-        for f in inspect.getouterframes(inspect.currentframe())
-        if f.filename != cur_filename
-    )
+    outer_frame = next(f for f in inspect.getouterframes(inspect.currentframe()) if f.filename != cur_filename)
     variables.update(outer_frame.frame.f_globals)
     variables.update(outer_frame.frame.f_locals)
     return variables
 
 
-def extract_table_names(query: str) -> Set[str]:
+def extract_table_names(query: str) -> set[str]:
     """Extract table names from an SQL query."""
     # a good old fashioned regex. turns out this worked better than actually parsing the code
     tables_blocks = re.findall(
@@ -176,7 +175,7 @@ def extract_table_names(query: str) -> Set[str]:
 def write_table(
     df: DataFrame,
     tablename: str,
-    conn: Union[Engine, Connection, sqlite3.Connection],
+    conn: Engine | Connection | sqlite3.Connection,
 ) -> None:
     """Write Pandas DataFrame to SQL Table.
 
@@ -205,9 +204,9 @@ def write_table(
 
 def sqldf(
     query: str,
-    env: Optional[Dict[str, Any]] = None,
-    db_uri: Optional[str] = None,
-) -> Optional[DataFrame]:
+    env: dict[str, Any] | None = None,
+    db_uri: str | None = None,
+) -> DataFrame | None:
     """Query pandas data frames using sql syntax.
 
     This function is meant for backward compatibility only. New users are encouraged to use the PandaSQL class.

pandas_query_sql-0.8.1/AUTHORS.md

@@ -1,11 +0,0 @@
-##Authors
-
-- Greg Lamp
-- Austin Ogilvie
-
-##Patches
-- Colin Dickson
-- stonebig
-
-##Fork author
-- Alexander Plavin

pandas_query_sql-0.8.1/tests/pandasql/test_pandasql.py

@@ -1,335 +0,0 @@
-import importlib.metadata
-import string
-from typing import Dict
-
-import packaging.version
-import pandas as pd
-import pandas.testing as pdtest
-import pytest
-
-from pandasql import PandaSQL, PandaSQLException, load_meat, sqldf
-
-PANDAS_MAJOR_VERSION = packaging.version.Version(
-    importlib.metadata.version("pandas"),
-).major
-
-
-@pytest.fixture()
-def db_uris() -> Dict[str, str]:
-    return {
-        "sqlite": "sqlite:///:memory:",
-        "postgres": "postgresql://postgres@localhost/",
-    }
-
-
-@pytest.fixture(params=["sqlite", "postgres"])
-def db_flavor(request: pytest.FixtureRequest) -> str:
-    return str(request.param)
-
-
-@pytest.fixture()
-def db_uri(db_uris: Dict[str, str], db_flavor: str) -> str:
-    return db_uris[db_flavor]
-
-
-@pytest.fixture(params=[False, True])
-def pdsql(db_uri: str, request: pytest.FixtureRequest) -> PandaSQL:
-    return PandaSQL(db_uri, persist=request.param)
-
-
-def test_select_legacy(db_uri: str) -> None:
-    df = pd.DataFrame(
-        {
-            "letter_pos": range(len(string.ascii_letters)),
-            "l2": list(string.ascii_letters),
-        },
-    )
-    result = sqldf("SELECT * FROM df LIMIT 10", db_uri=db_uri)
-
-    assert result is not None
-    assert len(result) == 10
-    pdtest.assert_frame_equal(df.head(10), result)
-
-
-def test_select(pdsql: PandaSQL) -> None:
-    df = pd.DataFrame(
-        {
-            "letter_pos": range(len(string.ascii_letters)),
-            "l2": list(string.ascii_letters),
-        },
-    )
-    result = pdsql("SELECT * FROM df LIMIT 10")
-
-    assert result is not None
-    assert len(result) == 10
-    pdtest.assert_frame_equal(df.head(10), result)
-
-
-def test_join(pdsql: PandaSQL) -> None:
-    df = pd.DataFrame(
-        {
-            "letter_pos": range(len(string.ascii_letters)),
-            "l2": list(string.ascii_letters),
-        },
-    )
-
-    df2 = pd.DataFrame(
-        {
-            "letter_pos": range(len(string.ascii_letters)),
-            "letter": list(string.ascii_letters),
-        },
-    )
-
-    result = pdsql(
-        "SELECT a.*, b.letter FROM df a INNER JOIN df2 b ON a.l2 = b.letter LIMIT 20",
-    )
-
-    assert result is not None
-    assert len(result) == 20
-    pdtest.assert_frame_equal(
-        df[["letter_pos", "l2"]].head(20),
-        result[["letter_pos", "l2"]],
-    )
-    pdtest.assert_frame_equal(df2[["letter"]].head(20), result[["letter"]])
-
-
-def test_query_with_spacing(pdsql: PandaSQL) -> None:
-    df = pd.DataFrame(
-        {
-            "letter_pos": range(len(string.ascii_letters)),
-            "l2": list(string.ascii_letters),
-        },
-    )
-    assert df is not None
-
-    df2 = pd.DataFrame(
-        {
-            "letter_pos": range(len(string.ascii_letters)),
-            "letter": list(string.ascii_letters),
-        },
-    )
-    assert df2 is not None
-
-    expected = pdsql(
-        "SELECT a.*, b.letter FROM df a INNER JOIN df2 b ON a.l2 = b.letter LIMIT 20",
-    )
-    assert expected is not None
-
-    q = """
-        SELECT
-        a.*
-    , b.letter
-    FROM
-        df a
-    INNER JOIN
-        df2 b
-    on a.l2 = b.letter
-    LIMIT 20
-    """
-    result = pdsql(q)
-    assert result is not None
-    assert len(result) == 20
-    pdtest.assert_frame_equal(expected, result)
-
-
-def test_subquery(pdsql: PandaSQL) -> None:
-    kermit = pd.DataFrame({"x": range(10)})
-    result = pdsql("SELECT * FROM (SELECT * FROM kermit) tbl LIMIT 2")
-    assert result is not None
-    pdtest.assert_frame_equal(kermit.head(2), result)
-    assert len(result) == 2
-
-
-def test_in(pdsql: PandaSQL) -> None:
-    course_data = {
-        "coursecode": ["TM351", "TU100", "M269"],
-        "points": [30, 60, 30],
-        "level": ["3", "1", "2"],
-    }
-    course_df = pd.DataFrame(course_data)
-    assert not course_df.empty
-
-    result = pdsql("SELECT * FROM course_df WHERE coursecode IN ( 'TM351', 'TU100' )")
-    assert result is not None
-    assert len(result) == 2
-
-
-def test_in_with_subquery(pdsql: PandaSQL) -> None:
-    program_data = {
-        "coursecode": [
-            "TM351",
-            "TM351",
-            "TM351",
-            "TU100",
-            "TU100",
-            "TU100",
-            "M269",
-            "M269",
-            "M269",
-        ],
-        "programCode": ["AB1", "AB2", "AB3", "AB1", "AB3", "AB4", "AB3", "AB4", "AB5"],
-    }
-    program_df = pd.DataFrame(program_data)
-    assert not program_df.empty
-
-    course_data = {
-        "coursecode": ["TM351", "TU100", "M269"],
-        "points": [30, 60, 30],
-        "level": ["3", "1", "2"],
-    }
-    course_df = pd.DataFrame(course_data)
-    assert not course_df.empty
-
-    result = pdsql(
-        "SELECT * FROM course_df WHERE coursecode IN ( SELECT DISTINCT coursecode FROM program_df )",
-    )
-    assert result is not None
-    assert len(result) == 3
-
-
-def test_datetime_query(pdsql: PandaSQL, db_flavor: str) -> None:
-    meat = load_meat()
-    expected = meat[meat["date"] >= "2012-01-01"].reset_index(drop=True)
-    result = pdsql("SELECT * FROM meat WHERE date >= '2012-01-01'")
-    assert result is not None
-
-    if db_flavor == "sqlite":
-        # sqlite uses strings instead of datetimes
-        pdtest.assert_frame_equal(
-            expected.drop(labels="date", axis="columns"),
-            result.drop(labels="date", axis="columns"),
-        )
-    else:
-        pdtest.assert_frame_equal(expected, result)
-
-
-def test_returning_single(pdsql: PandaSQL) -> None:
-    meat = load_meat()
-    result = pdsql("SELECT beef FROM meat LIMIT 10")
-    assert result is not None
-    assert len(result) == 10
-    pdtest.assert_frame_equal(meat[["beef"]].head(10), result)
-
-
-def test_name_index(pdsql: PandaSQL) -> None:
-    df = pd.DataFrame(
-        {
-            "index": range(len(string.ascii_letters)),
-            "level_0": range(len(string.ascii_letters)),
-            "level_1": range(len(string.ascii_letters)),
-            "letter": list(string.ascii_letters),
-        },
-    )
-    result = pdsql("SELECT * FROM df")
-    assert result is not None
-    pdtest.assert_frame_equal(df, result)
-
-
-def test_nonexistent_table(pdsql: PandaSQL) -> None:
-    with pytest.raises(PandaSQLException):
-        pdsql("SELECT * FROM nosuchtablereally")
-
-
-def test_system_tables(pdsql: PandaSQL, db_flavor: str) -> None:
-    if db_flavor == "sqlite":
-        # sqlite doesn't have information_schema
-        result = pdsql("SELECT * FROM sqlite_master")
-    else:
-        result = pdsql("SELECT * FROM information_schema.tables")
-    assert result is not None
-    assert len(result.columns) > 1
-
-
-@pytest.mark.parametrize(
-    "db_flavor",
-    ["postgres"],
-)  # sqlite doesn't support tables with no columns
-def test_no_columns(pdsql: PandaSQL) -> None:
-    df = pd.DataFrame()
-    result = pdsql("SELECT * FROM df")
-    assert result is not None
-    assert df.empty
-    assert result.empty
-    pdtest.assert_frame_equal(df, result, check_column_type=(PANDAS_MAJOR_VERSION < 2))
-
-
-def test_empty(pdsql: PandaSQL) -> None:
-    df = pd.DataFrame({"x": []})
-    result = pdsql("SELECT * FROM df")
-    assert result is not None
-    assert result.empty
-    pdtest.assert_index_equal(df.columns, result.columns)
-
-
-def test_noleak_legacy(db_uri: str) -> None:
-    df = pd.DataFrame({"x": [1]})
-    result = sqldf("SELECT * FROM df", db_uri=db_uri)
-    assert result is not None
-    pdtest.assert_frame_equal(df, result)
-    del df
-    with pytest.raises(PandaSQLException):
-        result = sqldf("SELECT * FROM df", db_uri=db_uri)
-
-
-@pytest.mark.parametrize("pdsql", [False], indirect=True)
-def test_noleak_class(pdsql: PandaSQL) -> None:
-    df = pd.DataFrame({"x": [1]})
-    result = pdsql("SELECT * FROM df")
-    assert result is not None
-    pdtest.assert_frame_equal(df, result)
-    del df
-    with pytest.raises(PandaSQLException):
-        result = pdsql("SELECT * FROM df")
-
-
-def test_same_query_noerr(pdsql: PandaSQL) -> None:
-    df = pd.DataFrame({"x": [1]})
-    result1 = pdsql("SELECT * FROM df")
-    assert result1 is not None
-    pdtest.assert_frame_equal(df, result1)
-    result2 = pdsql("SELECT * FROM df")
-    assert result2 is not None
-    pdtest.assert_frame_equal(result1, result2)
-
-
-@pytest.mark.parametrize("pdsql", [True], indirect=True)
-def test_persistent(pdsql: PandaSQL) -> None:
-    df = pd.DataFrame({"x": [1]})
-    result1 = pdsql("SELECT * FROM df")
-    assert result1 is not None
-    pdtest.assert_frame_equal(df, result1)
-
-    del df
-    result2 = pdsql("SELECT * FROM df")
-    assert result2 is not None
-    pdtest.assert_frame_equal(result1, result2)
-
-    df = pd.DataFrame({"x": [1, 2]})  # will not have any effect
-    assert not df.empty
-    result3 = pdsql("SELECT * FROM df")
-    assert result3 is not None
-    pdtest.assert_frame_equal(result1, result3)
-
-    df1 = pd.DataFrame({"x": [1, 2, 3]})
-    result4 = pdsql("SELECT * FROM df1")
-    assert result4 is not None
-    pdtest.assert_frame_equal(df1, result4)
-
-
-def test_noreturn_query(pdsql: PandaSQL) -> None:
-    assert pdsql("CREATE TABLE tbl (col INTEGER)") is None
-
-
-@pytest.mark.parametrize("pdsql", [False], indirect=True)
-def test_no_sideeffect_leak(pdsql: PandaSQL) -> None:
-    pdsql("CREATE TABLE tbl (col INTEGER)")
-    with pytest.raises(PandaSQLException):
-        pdsql("SELECT * FROM tbl")
-
-
-@pytest.mark.parametrize("pdsql", [True], indirect=True)
-def test_sideeffect_persist(pdsql: PandaSQL) -> None:
-    pdsql("CREATE TABLE tbl (col INTEGER)")
-    result = pdsql("SELECT * FROM tbl")
-    assert result is not None
-    assert list(result.columns) == ["col"]

pandas_query_sql-0.8.1/tests/pandasql/test_utils.py

@@ -1,46 +0,0 @@
-from typing import Set
-
-import pytest
-
-from pandasql.sqldf import extract_table_names, get_outer_frame_variables
-
-
-def test_get_vars() -> None:
-    var_a = 123
-    variable = {"a": "b", "c": "d"}
-    assert get_outer_frame_variables()["var_a"] == var_a
-    assert get_outer_frame_variables()["variable"] == variable
-
-
-@pytest.mark.parametrize(
-    ("query", "expected"),
-    [
-        ("", set()),
-        ("SELECT * FROM dbtbl LIMIT 10", {"dbtbl"}),
-        ("SELECT * from dbtbl LIMIT 10", {"dbtbl"}),
-        (
-            "SELECT * FROM dbtbl JOIN table_2 USING (a) LEFT JOIN mytable USING (b)",
-            {"dbtbl", "table_2", "mytable"},
-        ),
-        (
-            "SELECT * FROM dbtbl, table_2, mytable JOIN another USING (a)",
-            {"dbtbl", "table_2", "mytable", "another"},
-        ),
-        ("SELECT * FROM dbtbl, table_2 JOIN dbtbl USING (a)", {"dbtbl", "table_2"}),
-        pytest.param(
-            "SELECT * FROM dbtbl WHERE col = 'Go and join us!'",
-            {"dbtbl"},
-            marks=pytest.mark.xfail,
-        ),
-        (
-            "SELECT * FROM course_df WHERE coursecode IN ( SELECT DISTINCT coursecode FROM program_df )",
-            {"course_df", "program_df"},
-        ),
-        (
-            "SELECT * FROM course_df, (SELECT coursecode FROM program_df) ssel",
-            {"course_df", "program_df"},
-        ),
-    ],
-)
-def test_extract_table_names(query: str, expected: Set[str]) -> None:
-    assert extract_table_names(query) == expected