pandas-query-sql 0.8.0__tar.gz → 0.8.2__tar.gz

{pandas_query_sql-0.8.0 → pandas_query_sql-0.8.2}/PKG-INFO

@@ -1,24 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pandas_query_sql
-Version: 0.8.0
+Version: 0.8.2
 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-binary; extra == "postgresql"
-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.10
+Project-URL: Homepage, https://github.com/bluestealth/pandasql/
 Provides-Extra: postgresql
-Provides-Extra: linters
-Provides-Extra: testing
+Provides-Extra: postgresql-binary
 Description-Content-Type: text/markdown
 
 pandasql

pandas_query_sql-0.8.2/pyproject.toml

@@ -0,0 +1,74 @@
+[project]
+name = "pandas_query_sql"
+version = "0.8.2"
+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.10"
+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.11.28,<0.12"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "pandasql"
+
+[tool.ty.src]
+exclude = ["examples/**"]
+
+[tool.ruff]
+line-length = 120
+target-version = 'py310'
+
+[tool.ruff.lint]
+select = ['ALL']
+ignore = ['COM812', '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.0 → pandas_query_sql-0.8.2}/src/pandasql/__init__.py

@@ -1,4 +1,4 @@
-import os
+import pathlib
 
 import pandas as pd
 
@@ -6,11 +6,11 @@ from .sqldf import PandaSQL, PandaSQLException, sqldf
 
 __all__ = ["PandaSQL", "PandaSQLException", "sqldf"]
 
-_ROOT = os.path.abspath(os.path.dirname(__file__))
+_ROOT = pathlib.Path(__file__).absolute().parent
 
 
-def get_data(path: str) -> str:
-    return os.path.join(_ROOT, "data", path)
+def get_data(path: str) -> pathlib.Path:
+    return _ROOT.joinpath("data", path)
 
 
 def load_meat() -> pd.DataFrame:

{pandas_query_sql-0.8.0 → pandas_query_sql-0.8.2}/src/pandasql/sqldf.py

@@ -4,43 +4,46 @@ import importlib.metadata
 import inspect
 import re
 import sqlite3
+from collections.abc import Iterator
 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
+from sqlalchemy import create_engine  # pyright: ignore[reportUnknownVariableType]
 from sqlalchemy.engine import Connection, Engine
-from sqlalchemy.event import listen
-from sqlalchemy.exc import DatabaseError, ResourceClosedError
+from sqlalchemy.event import listen  # pyright: ignore[reportUnknownVariableType]
+from sqlalchemy.exc import DatabaseError as SQLAlchemyDatabaseError
+from sqlalchemy.exc import ResourceClosedError
 from sqlalchemy.pool import NullPool
-from sqlalchemy.pool.base import _ConnectionRecord
+from sqlalchemy.pool.base import (
+    _ConnectionRecord,  # pyright: ignore[reportPrivateUsage]
+)
 
 __all__ = ["PandaSQL", "PandaSQLException", "sqldf"]
 
 SQLALCHEMY_MAJOR_VERSION = packaging.version.Version(
-    importlib.metadata.version("sqlalchemy")
+    importlib.metadata.version("sqlalchemy"),
 ).major
 
 
 class PandaSQLException(Exception):
     """Exception Class for PandaSQL."""
 
-    pass
-
 
 class PandaSQL:
     """Class for using SQL database to query pandas DataFrames.
 
     Attributes:
         engine: sqlalchemy database engine
-        persist: boolean to determine if tables stay loaded between function calls 
+        persist: boolean to determine if tables stay loaded between function calls
         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.
@@ -49,7 +52,7 @@ class PandaSQL:
         if not db_uri:
             db_uri = "sqlite:///:memory:"
 
-        self.engine = create_engine(url=db_uri, poolclass=NullPool)
+        self.engine: Engine = create_engine(url=db_uri, poolclass=NullPool)
 
         if self.engine.name == "sqlite":
             listen(target=self.engine, identifier="connect", fn=self._set_text_factory)
@@ -57,18 +60,20 @@ class PandaSQL:
             pass
         else:
             raise PandaSQLException(
-                "Currently only sqlite and postgresql are supported."
+                "Currently only sqlite and postgresql are supported.",
             )
 
         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)
 
     def __call__(
-        self, query: str, env: Optional[Dict[str, Any]] = None
-    ) -> Optional[DataFrame]:
+        self,
+        query: str,
+        env: dict[str, Any] | None = None,
+    ) -> DataFrame | None:
         """Execute the SQL query.
 
         Automatically creates tables mentioned in the query from dataframes before executing.
@@ -94,11 +99,11 @@ class PandaSQL:
 
             try:
                 result = read_sql_query(sql=query, con=conn)
-            except DatabaseError as ex:
-                raise PandaSQLException(ex)
             except ResourceClosedError:
                 # query returns nothing
                 result = None
+            except (SQLAlchemyDatabaseError, PandasDatabaseError) as ex:
+                raise PandaSQLException(ex) from ex
 
         return result
 
@@ -123,48 +128,54 @@ 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(statement=text("set search_path to pg_temp"))
+                conn.execute(  # pyright: ignore[reportUnknownMemberType]
+                    statement=text("set search_path to pg_temp"),
+                )
             else:
-                conn.execute(statement="set search_path to pg_temp")
+                conn.execute(  # ty: ignore[no-matching-overload]
+                    statement="set search_path to pg_temp",
+                )
 
     def _set_text_factory(
-        self, dbapi_conn: sqlite3.Connection, _: _ConnectionRecord
+        self,
+        dbapi_conn: sqlite3.Connection,
+        _: _ConnectionRecord,
     ) -> None:
         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(
-        r"(?:FROM|JOIN)\s+(\w+(?:\s*,\s*\w+)*)", query, re.IGNORECASE
+        r"(?:FROM|JOIN)\s+(\w+(?:\s*,\s*\w+)*)",
+        query,
+        re.IGNORECASE,
     )
     return {tbl for block in tables_blocks for tbl in re.findall(r"\w+", block)}
 
 
 def write_table(
-    df: DataFrame, tablename: str, conn: Union[Engine, Connection, sqlite3.Connection]
+    df: DataFrame,
+    tablename: str,
+    conn: Engine | Connection | sqlite3.Connection,
 ) -> None:
     """Write Pandas DataFrame to SQL Table.
 
@@ -184,13 +195,18 @@ def write_table(
         df.to_sql(
             name=tablename,
             con=conn,
-            index=not any(name is None for name in df.index.names),  # type: ignore
+            index=not any(
+                name is None  # pyright: ignore[reportUnnecessaryComparison]
+                for name in df.index.names  # pyright: ignore[reportUnknownMemberType]
+            ),
         )  # load index into db if all levels are named
 
 
 def sqldf(
-    query: str, env: Optional[Dict[str, Any]] = None, db_uri: Optional[str] = None
-) -> Optional[DataFrame]:
+    query: str,
+    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.0/AUTHORS.md

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

pandas_query_sql-0.8.0/pyproject.toml

@@ -1,109 +0,0 @@
-[project]
-name = "pandas_query_sql"
-version = "0.8.0"
-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"
-readme = "README.md"
-classifiers = [
-    "License :: OSI Approved :: MIT License",
-]
-
-[project.license]
-text = "MIT"
-
-[project.urls]
-Homepage = "https://github.com/bluestealth/pandasql/"
-
-[project.optional-dependencies]
-postgresql = [
-    "psycopg2-binary",
-]
-linters = [
-    "black",
-    "ruff",
-]
-testing = [
-    "pytest",
-    "psycopg2-binary",
-]
-
-[build-system]
-requires = [
-    "pdm-backend",
-]
-build-backend = "pdm.backend"
-
-[tool.pdm]
-distribution = true
-
-[tool.pdm.package-dir]
-pandasql = "pandasql"
-
-[tool.setuptools.package-data]
-pandasql = [
-    "data/births.csv",
-    "data/birth_by_months.csv",
-    "data/meat.csv",
-]
-
-[tool.ruff]
-line-length = 120
-target-version = "py38"
-
-[tool.ruff.lint]
-extend-select = [
-    "Q",
-    "RUF100",
-    "C90",
-    "UP",
-    "I",
-    "D",
-    "T",
-]
-extend-ignore = []
-
-[tool.ruff.lint.flake8-quotes]
-
-[tool.ruff.lint.isort]
-known-first-party = []
-
-[tool.ruff.lint.mccabe]
-max-complexity = 14
-
-[tool.ruff.lint.pydocstyle]
-convention = "google"
-
-[tool.ruff.lint.per-file-ignores]
-"src/pandasql/__init__.py" = [
-    "D",
-]
-"examples/**/*.py" = [
-    "D",
-]
-"tests/**/*.py" = [
-    "D",
-]
-
-[tool.ruff.lint.extend-per-file-ignores]
-"examples/**/*.py" = [
-    "T",
-]
-"tests/**/*.py" = [
-    "T",
-    "E721",
-    "F811",
-]
-
-[tool.ruff.format]
-quote-style = "double"

pandas_query_sql-0.8.0/tests/pandasql/test_pandasql.py

@@ -1,333 +0,0 @@
-import importlib.metadata
-import string
-from typing import Any, 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) -> Any:
-    return 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
-
-    courseData = {
-        "coursecode": ["TM351", "TU100", "M269"],
-        "points": [30, 60, 30],
-        "level": ["3", "1", "2"],
-    }
-    course_df = pd.DataFrame(courseData)
-    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 and 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):
-        result = pdsql("SELECT * FROM tbl")
-        assert result is not None
-
-
-@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.0/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