From 9da0e5f7108e718c57ba8690f7cc15e622bad9df Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Tue, 22 Oct 2024 16:00:48 +0530 Subject: [PATCH 01/11] sqlalchemy v1 initial setup --- README.tests.md | 44 -- example.py | 115 ++++ pyproject.toml | 15 +- src/databricks/sqlalchemy/__init__.py | 5 +- src/databricks/sqlalchemy/_ddl.py | 100 ---- src/databricks/sqlalchemy/_parse.py | 385 ------------- src/databricks/sqlalchemy/_types.py | 323 ----------- src/databricks/sqlalchemy/base.py | 436 -------------- .../dependency_test/test_dependency.py | 22 - src/databricks/sqlalchemy/dialect/__init__.py | 340 +++++++++++ src/databricks/sqlalchemy/dialect/base.py | 17 + src/databricks/sqlalchemy/dialect/compiler.py | 38 ++ src/databricks/sqlalchemy/py.typed | 0 src/databricks/sqlalchemy/pytest.ini | 4 - src/databricks/sqlalchemy/requirements.py | 249 -------- src/databricks/sqlalchemy/setup.cfg | 4 - src/databricks/sqlalchemy/test/_extra.py | 70 --- src/databricks/sqlalchemy/test/_future.py | 331 ----------- src/databricks/sqlalchemy/test/_regression.py | 311 ---------- .../sqlalchemy/test/_unsupported.py | 450 --------------- src/databricks/sqlalchemy/test/conftest.py | 13 - .../overrides/_componentreflectiontest.py | 189 ------ .../sqlalchemy/test/overrides/_ctetest.py | 33 -- src/databricks/sqlalchemy/test/test_suite.py | 13 - .../sqlalchemy/test_local/__init__.py | 5 - .../sqlalchemy/test_local/conftest.py | 44 -- .../sqlalchemy/test_local/e2e/MOCK_DATA.xlsx | Bin 59837 -> 0 bytes .../sqlalchemy/test_local/e2e/test_basic.py | 543 ------------------ .../sqlalchemy/test_local/test_ddl.py | 96 ---- .../sqlalchemy/test_local/test_parsing.py | 160 ------ .../sqlalchemy/test_local/test_types.py | 161 ------ 31 files changed, 515 insertions(+), 4001 deletions(-) delete mode 100644 README.tests.md create mode 100644 example.py delete mode 100644 src/databricks/sqlalchemy/_ddl.py delete mode 100644 src/databricks/sqlalchemy/_parse.py delete mode 100644 src/databricks/sqlalchemy/_types.py delete mode 100644 src/databricks/sqlalchemy/base.py delete mode 100644 src/databricks/sqlalchemy/dependency_test/test_dependency.py create mode 100644 src/databricks/sqlalchemy/dialect/__init__.py create mode 100644 src/databricks/sqlalchemy/dialect/base.py create mode 100644 src/databricks/sqlalchemy/dialect/compiler.py delete mode 100755 src/databricks/sqlalchemy/py.typed delete mode 100644 src/databricks/sqlalchemy/pytest.ini delete mode 100644 src/databricks/sqlalchemy/requirements.py delete mode 100644 src/databricks/sqlalchemy/setup.cfg delete mode 100644 src/databricks/sqlalchemy/test/_extra.py delete mode 100644 src/databricks/sqlalchemy/test/_future.py delete mode 100644 src/databricks/sqlalchemy/test/_regression.py delete mode 100644 src/databricks/sqlalchemy/test/_unsupported.py delete mode 100644 src/databricks/sqlalchemy/test/conftest.py delete mode 100644 src/databricks/sqlalchemy/test/overrides/_componentreflectiontest.py delete mode 100644 src/databricks/sqlalchemy/test/overrides/_ctetest.py delete mode 100644 src/databricks/sqlalchemy/test/test_suite.py delete mode 100644 src/databricks/sqlalchemy/test_local/__init__.py delete mode 100644 src/databricks/sqlalchemy/test_local/conftest.py delete mode 100644 src/databricks/sqlalchemy/test_local/e2e/MOCK_DATA.xlsx delete mode 100644 src/databricks/sqlalchemy/test_local/e2e/test_basic.py delete mode 100644 src/databricks/sqlalchemy/test_local/test_ddl.py delete mode 100644 src/databricks/sqlalchemy/test_local/test_parsing.py delete mode 100644 src/databricks/sqlalchemy/test_local/test_types.py diff --git a/README.tests.md b/README.tests.md deleted file mode 100644 index 3ed92ab..0000000 --- a/README.tests.md +++ /dev/null @@ -1,44 +0,0 @@ -## SQLAlchemy Dialect Compliance Test Suite with Databricks - -The contents of the `test/` directory follow the SQLAlchemy developers' [guidance] for running the reusable dialect compliance test suite. Since not every test in the suite is applicable to every dialect, two options are provided to skip tests: - -- Any test can be skipped by subclassing its parent class, re-declaring the test-case and adding a `pytest.mark.skip` directive. -- Any test that is decorated with a `@requires` decorator can be skipped by marking the indicated requirement as `.closed()` in `requirements.py` - -We prefer to skip test cases directly with the first method wherever possible. We only mark requirements as `closed()` if there is no easier option to avoid a test failure. This principally occurs in test cases where the same test in the suite is parametrized, and some parameter combinations are conditionally skipped depending on `requirements.py`. If we skip the entire test method, then we skip _all_ permutations, not just the combinations we don't support. - -## Regression, Unsupported, and Future test cases - -We maintain three files of test cases that we import from the SQLAlchemy source code: - -* **`_regression.py`** contains all the tests cases with tests that we expect to pass for our dialect. Each one is marked with `pytest.mark.reiewed` to indicate that we've evaluated it for relevance. This file only contains base class declarations. -* **`_unsupported.py`** contains test cases that fail because of missing features in Databricks. We mark them as skipped with a `SkipReason` enumeration. If Databricks comes to support these features, those test or entire classes can be moved to `_regression.py`. -* **`_future.py`** contains test cases that fail because of missing features in the dialect itself, but which _are_ supported by Databricks generally. We mark them as skipped with a `FutureFeature` enumeration. These are features that have not been prioritised or that do not violate our acceptance criteria. All of these test cases will eventually move to either `_regression.py`. - -In some cases, only certain tests in class should be skipped with a `SkipReason` or `FutureFeature` justification. In those cases, we import the class into `_regression.py`, then import it from there into one or both of `_future.py` and `_unsupported.py`. If a class needs to be "touched" by regression, unsupported, and future, the class will be imported in that order. If an entire class should be skipped, then we do not import it into `_regression.py` at all. - -We maintain `_extra.py` with test cases that depend on SQLAlchemy's reusable dialect test fixtures but which are specific to Databricks (e.g TinyIntegerTest). - -## Running the reusable dialect tests - -``` -poetry shell -cd src/databricks/sqlalchemy/test -python -m pytest test_suite.py --dburi \ - "databricks://token:$access_token@$host?http_path=$http_path&catalog=$catalog&schema=$schema" -``` - -Whatever schema you pass in the `dburi` argument should be empty. Some tests also require the presence of an empty schema named `test_schema`. Note that we plan to implement our own `provision.py` which SQLAlchemy can automatically use to create an empty schema for testing. But for now this is a manual process. - -You can run only reviewed tests by appending `-m "reviewed"` to the test runner invocation. - -You can run only the unreviewed tests by appending `-m "not reviewed"` instead. - -Note that because these tests depend on SQLAlchemy's custom pytest plugin, they are not discoverable by IDE-based test runners like VSCode or PyCharm and must be invoked from a CLI. - -## Running local unit and e2e tests - -Apart from the SQLAlchemy reusable suite, we maintain our own unit and e2e tests under the `test_local/` directory. These can be invoked from a VSCode or Pycharm since they don't depend on a custom pytest plugin. Due to pytest's lookup order, the `pytest.ini` which is required for running the reusable dialect tests, also conflicts with VSCode and Pycharm's default pytest implementation and overrides the settings in `pyproject.toml`. So to run these tests, you can delete or rename `pytest.ini`. - - -[guidance]: "https://github.com/sqlalchemy/sqlalchemy/blob/rel_2_0_22/README.dialects.rst" diff --git a/example.py b/example.py new file mode 100644 index 0000000..d9581bf --- /dev/null +++ b/example.py @@ -0,0 +1,115 @@ +""" +databricks-sql-connector includes a SQLAlchemy dialect compatible with Databricks SQL. +It aims to be a drop-in replacement for the crflynn/sqlalchemy-databricks project, that implements +more of the Databricks API, particularly around table reflection, Alembic usage, and data +ingestion with pandas. + +Expected URI format is: databricks+thrift://token:dapi***@***.cloud.databricks.com?http_path=/sql/*** + +Because of the extent of SQLAlchemy's capabilities it isn't feasible to provide examples of every +usage in a single script, so we only provide a basic one here. More examples are found in our test +suite at tests/e2e/sqlalchemy/test_basic.py and in the PR that implements this change: + +https://github.com/databricks/databricks-sql-python/pull/57 + +# What's already supported + +Most of the functionality is demonstrated in the e2e tests mentioned above. The below list we +derived from those test method names: + + - Create and drop tables with SQLAlchemy Core + - Create and drop tables with SQLAlchemy ORM + - Read created tables via reflection + - Modify column nullability + - Insert records manually + - Insert records with pandas.to_sql (note that this does not work for DataFrames with indexes) + +This connector also aims to support Alembic for programmatic delta table schema maintenance. This +behaviour is not yet backed by integration tests, which will follow in a subsequent PR as we learn +more about customer use cases there. That said, the following behaviours have been tested manually: + + - Autogenerate revisions with alembic revision --autogenerate + - Upgrade and downgrade between revisions with `alembic upgrade ` and + `alembic downgrade ` + +# Known Gaps + - MAP, ARRAY, and STRUCT types: this dialect can read these types out as strings. But you cannot + define a SQLAlchemy model with databricks.sqlalchemy.dialect.types.DatabricksMap (e.g.) because + we haven't implemented them yet. + - Constraints: with the addition of information_schema to Unity Catalog, Databricks SQL supports + foreign key and primary key constraints. This dialect can write these constraints but the ability + for alembic to reflect and modify them programmatically has not been tested. +""" + +import os +import sqlalchemy +from sqlalchemy.orm import Session +from sqlalchemy import Column, String, Integer, BOOLEAN, create_engine, select + +try: + from sqlalchemy.orm import declarative_base +except ImportError: + from sqlalchemy.ext.declarative import declarative_base + +host = os.getenv("DATABRICKS_SERVER_HOSTNAME") +http_path = os.getenv("DATABRICKS_HTTP_PATH") +access_token = os.getenv("DATABRICKS_TOKEN") +catalog = os.getenv("DATABRICKS_CATALOG") +schema = os.getenv("DATABRICKS_SCHEMA") + + +# Extra arguments are passed untouched to the driver +# See thrift_backend.py for complete list +extra_connect_args = { + "_tls_verify_hostname": True, + "_user_agent_entry": "PySQL Example Script", +} + +if sqlalchemy.__version__.startswith("1.3"): + # SQLAlchemy 1.3.x fails to parse the http_path, catalog, and schema from our connection string + # Pass these in as connect_args instead + + conn_string = f"databricks://token:{access_token}@{host}" + connect_args = dict(catalog=catalog, schema=schema, http_path=http_path) + all_connect_args = {**extra_connect_args, **connect_args} + engine = create_engine(conn_string, connect_args=all_connect_args) +else: + engine = create_engine( + f"databricks://token:{access_token}@{host}?http_path={http_path}&catalog={catalog}&schema={schema}", + connect_args=extra_connect_args, + ) + +session = Session(bind=engine) +base = declarative_base(bind=engine) + + +class SampleObject(base): + + __tablename__ = "mySampleTable" + + name = Column(String(255), primary_key=True) + episodes = Column(Integer) + some_bool = Column(BOOLEAN) + + +base.metadata.create_all() + +sample_object_1 = SampleObject(name="Bim Adewunmi", episodes=6, some_bool=True) +sample_object_2 = SampleObject(name="Miki Meek", episodes=12, some_bool=False) + +session.add(sample_object_1) +session.add(sample_object_2) + +session.commit() + +# SQLAlchemy 1.3 has slightly different methods +if sqlalchemy.__version__.startswith("1.3"): + stmt = select([SampleObject]).where(SampleObject.name.in_(["Bim Adewunmi", "Miki Meek"])) + output = [i for i in session.execute(stmt)] +else: + stmt = select(SampleObject).where(SampleObject.name.in_(["Bim Adewunmi", "Miki Meek"])) + output = [i for i in session.scalars(stmt)] + +assert len(output) == 2 + +base.metadata.drop_all() diff --git a/pyproject.toml b/pyproject.toml index a87460a..c6bc2c8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "databricks-sqlalchemy" -version = "1.0.0" +version = "1.0.1" description = "Databricks SQLAlchemy plugin for Python" authors = ["Databricks "] license = "Apache-2.0" @@ -10,8 +10,8 @@ include = ["CHANGELOG.md"] [tool.poetry.dependencies] python = "^3.8.0" -databricks_sql_connector_core = { version = ">=1.0.0"} -sqlalchemy = { version = ">=2.0.21" } +databricks_sql_connector_core = { version = ">=4.0.0"} +sqlalchemy = { version = "^1.3.24" } [tool.poetry.dev-dependencies] pytest = "^7.1.2" @@ -33,11 +33,4 @@ build-backend = "poetry.core.masonry.api" [tool.black] exclude = '/(\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|\.svn|_build|buck-out|build|dist|thrift_api)/' -# -[tool.pytest.ini_options] -markers = {"reviewed" = "Test case has been reviewed by Databricks"} -minversion = "6.0" -log_cli = "false" -log_cli_level = "INFO" -testpaths = ["tests", "src/databricks/sqlalchemy/test_local"] -env_files = ["test.env"] + diff --git a/src/databricks/sqlalchemy/__init__.py b/src/databricks/sqlalchemy/__init__.py index 2a17ac3..1df1e1d 100644 --- a/src/databricks/sqlalchemy/__init__.py +++ b/src/databricks/sqlalchemy/__init__.py @@ -1,4 +1 @@ -from databricks.sqlalchemy.base import DatabricksDialect -from databricks.sqlalchemy._types import TINYINT, TIMESTAMP, TIMESTAMP_NTZ - -__all__ = ["TINYINT", "TIMESTAMP", "TIMESTAMP_NTZ"] +from databricks.sqlalchemy.dialect import DatabricksDialect diff --git a/src/databricks/sqlalchemy/_ddl.py b/src/databricks/sqlalchemy/_ddl.py deleted file mode 100644 index d5d0bf8..0000000 --- a/src/databricks/sqlalchemy/_ddl.py +++ /dev/null @@ -1,100 +0,0 @@ -import re -from sqlalchemy.sql import compiler, sqltypes -import logging - -logger = logging.getLogger(__name__) - - -class DatabricksIdentifierPreparer(compiler.IdentifierPreparer): - """https://docs.databricks.com/en/sql/language-manual/sql-ref-identifiers.html""" - - legal_characters = re.compile(r"^[A-Z0-9_]+$", re.I) - - def __init__(self, dialect): - super().__init__(dialect, initial_quote="`") - - -class DatabricksDDLCompiler(compiler.DDLCompiler): - def post_create_table(self, table): - post = [" USING DELTA"] - if table.comment: - comment = self.sql_compiler.render_literal_value( - table.comment, sqltypes.String() - ) - post.append("COMMENT " + comment) - - post.append("TBLPROPERTIES('delta.feature.allowColumnDefaults' = 'enabled')") - return "\n".join(post) - - def visit_unique_constraint(self, constraint, **kw): - logger.warning("Databricks does not support unique constraints") - pass - - def visit_check_constraint(self, constraint, **kw): - logger.warning("This dialect does not support check constraints") - pass - - def visit_identity_column(self, identity, **kw): - """When configuring an Identity() with Databricks, only the always option is supported. - All other options are ignored. - - Note: IDENTITY columns must always be defined as BIGINT. An exception will be raised if INT is used. - - https://www.databricks.com/blog/2022/08/08/identity-columns-to-generate-surrogate-keys-are-now-available-in-a-lakehouse-near-you.html - """ - text = "GENERATED %s AS IDENTITY" % ( - "ALWAYS" if identity.always else "BY DEFAULT", - ) - return text - - def visit_set_column_comment(self, create, **kw): - return "ALTER TABLE %s ALTER COLUMN %s COMMENT %s" % ( - self.preparer.format_table(create.element.table), - self.preparer.format_column(create.element), - self.sql_compiler.render_literal_value( - create.element.comment, sqltypes.String() - ), - ) - - def visit_drop_column_comment(self, create, **kw): - return "ALTER TABLE %s ALTER COLUMN %s COMMENT ''" % ( - self.preparer.format_table(create.element.table), - self.preparer.format_column(create.element), - ) - - def get_column_specification(self, column, **kwargs): - """ - Emit a log message if a user attempts to set autoincrement=True on a column. - See comments in test_suite.py. We may implement implicit IDENTITY using this - feature in the future, similar to the Microsoft SQL Server dialect. - """ - if column is column.table._autoincrement_column or column.autoincrement is True: - logger.warning( - "Databricks dialect ignores SQLAlchemy's autoincrement semantics. Use explicit Identity() instead." - ) - - colspec = super().get_column_specification(column, **kwargs) - if column.comment is not None: - literal = self.sql_compiler.render_literal_value( - column.comment, sqltypes.STRINGTYPE - ) - colspec += " COMMENT " + literal - - return colspec - - -class DatabricksStatementCompiler(compiler.SQLCompiler): - def limit_clause(self, select, **kw): - """Identical to the default implementation of SQLCompiler.limit_clause except it writes LIMIT ALL instead of LIMIT -1, - since Databricks SQL doesn't support the latter. - - https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-qry-select-limit.html - """ - text = "" - if select._limit_clause is not None: - text += "\n LIMIT " + self.process(select._limit_clause, **kw) - if select._offset_clause is not None: - if select._limit_clause is None: - text += "\n LIMIT ALL" - text += " OFFSET " + self.process(select._offset_clause, **kw) - return text diff --git a/src/databricks/sqlalchemy/_parse.py b/src/databricks/sqlalchemy/_parse.py deleted file mode 100644 index 6d38e1e..0000000 --- a/src/databricks/sqlalchemy/_parse.py +++ /dev/null @@ -1,385 +0,0 @@ -from typing import List, Optional, Dict -import re - -import sqlalchemy -from sqlalchemy.engine import CursorResult -from sqlalchemy.engine.interfaces import ReflectedColumn - -from databricks.sqlalchemy import _types as type_overrides - -""" -This module contains helper functions that can parse the contents -of metadata and exceptions received from DBR. These are mostly just -wrappers around regexes. -""" - - -class DatabricksSqlAlchemyParseException(Exception): - pass - - -def _match_table_not_found_string(message: str) -> bool: - """Return True if the message contains a substring indicating that a table was not found""" - - DBR_LTE_12_NOT_FOUND_STRING = "Table or view not found" - DBR_GT_12_NOT_FOUND_STRING = "TABLE_OR_VIEW_NOT_FOUND" - return any( - [ - DBR_LTE_12_NOT_FOUND_STRING in message, - DBR_GT_12_NOT_FOUND_STRING in message, - ] - ) - - -def _describe_table_extended_result_to_dict_list( - result: CursorResult, -) -> List[Dict[str, str]]: - """Transform the CursorResult of DESCRIBE TABLE EXTENDED into a list of Dictionaries""" - - rows_to_return = [] - for row in result.all(): - this_row = {"col_name": row.col_name, "data_type": row.data_type} - rows_to_return.append(this_row) - - return rows_to_return - - -def extract_identifiers_from_string(input_str: str) -> List[str]: - """For a string input resembling (`a`, `b`, `c`) return a list of identifiers ['a', 'b', 'c']""" - - # This matches the valid character list contained in DatabricksIdentifierPreparer - pattern = re.compile(r"`([A-Za-z0-9_]+)`") - matches = pattern.findall(input_str) - return [i for i in matches] - - -def extract_identifier_groups_from_string(input_str: str) -> List[str]: - """For a string input resembling : - - FOREIGN KEY (`pname`, `pid`, `pattr`) REFERENCES `main`.`pysql_sqlalchemy`.`tb1` (`name`, `id`, `attr`) - - Return ['(`pname`, `pid`, `pattr`)', '(`name`, `id`, `attr`)'] - """ - pattern = re.compile(r"\([`A-Za-z0-9_,\s]*\)") - matches = pattern.findall(input_str) - return [i for i in matches] - - -def extract_three_level_identifier_from_constraint_string(input_str: str) -> dict: - """For a string input resembling : - FOREIGN KEY (`parent_user_id`) REFERENCES `main`.`pysql_dialect_compliance`.`users` (`user_id`) - - Return a dict like - { - "catalog": "main", - "schema": "pysql_dialect_compliance", - "table": "users" - } - - Raise a DatabricksSqlAlchemyParseException if a 3L namespace isn't found - """ - pat = re.compile(r"REFERENCES\s+(.*?)\s*\(") - matches = pat.findall(input_str) - - if not matches: - raise DatabricksSqlAlchemyParseException( - "3L namespace not found in constraint string" - ) - - first_match = matches[0] - parts = first_match.split(".") - - def strip_backticks(input: str): - return input.replace("`", "") - - try: - return { - "catalog": strip_backticks(parts[0]), - "schema": strip_backticks(parts[1]), - "table": strip_backticks(parts[2]), - } - except IndexError: - raise DatabricksSqlAlchemyParseException( - "Incomplete 3L namespace found in constraint string: " + ".".join(parts) - ) - - -def _parse_fk_from_constraint_string(constraint_str: str) -> dict: - """Build a dictionary of foreign key constraint information from a constraint string. - - For example: - - ``` - FOREIGN KEY (`pname`, `pid`, `pattr`) REFERENCES `main`.`pysql_dialect_compliance`.`tb1` (`name`, `id`, `attr`) - ``` - - Return a dictionary like: - - ``` - { - "constrained_columns": ["pname", "pid", "pattr"], - "referred_table": "tb1", - "referred_schema": "pysql_dialect_compliance", - "referred_columns": ["name", "id", "attr"] - } - ``` - - Note that the constraint name doesn't appear in the constraint string so it will not - be present in the output of this function. - """ - - referred_table_dict = extract_three_level_identifier_from_constraint_string( - constraint_str - ) - referred_table = referred_table_dict["table"] - referred_schema = referred_table_dict["schema"] - - # _extracted is a tuple of two lists of identifiers - # we assume the first immediately follows "FOREIGN KEY" and the second - # immediately follows REFERENCES $tableName - _extracted = extract_identifier_groups_from_string(constraint_str) - constrained_columns_str, referred_columns_str = ( - _extracted[0], - _extracted[1], - ) - - constrained_columns = extract_identifiers_from_string(constrained_columns_str) - referred_columns = extract_identifiers_from_string(referred_columns_str) - - return { - "constrained_columns": constrained_columns, - "referred_table": referred_table, - "referred_columns": referred_columns, - "referred_schema": referred_schema, - } - - -def build_fk_dict( - fk_name: str, fk_constraint_string: str, schema_name: Optional[str] -) -> dict: - """ - Given a foriegn key name and a foreign key constraint string, return a dictionary - with the following keys: - - name - the name of the foreign key constraint - constrained_columns - a list of column names that make up the foreign key - referred_table - the name of the table that the foreign key references - referred_columns - a list of column names that are referenced by the foreign key - referred_schema - the name of the schema that the foreign key references. - - referred schema will be None if the schema_name argument is None. - This is required by SQLAlchey's ComponentReflectionTest::test_get_foreign_keys - """ - - # The foreign key name is not contained in the constraint string so we - # need to add it manually - base_fk_dict = _parse_fk_from_constraint_string(fk_constraint_string) - - if not schema_name: - schema_override_dict = dict(referred_schema=None) - else: - schema_override_dict = {} - - # mypy doesn't like this method of conditionally adding a key to a dictionary - # while keeping everything immutable - complete_foreign_key_dict = { - "name": fk_name, - **base_fk_dict, - **schema_override_dict, # type: ignore - } - - return complete_foreign_key_dict - - -def _parse_pk_columns_from_constraint_string(constraint_str: str) -> List[str]: - """Build a list of constrained columns from a constraint string returned by DESCRIBE TABLE EXTENDED - - For example: - - PRIMARY KEY (`id`, `name`, `email_address`) - - Returns a list like - - ["id", "name", "email_address"] - """ - - _extracted = extract_identifiers_from_string(constraint_str) - - return _extracted - - -def build_pk_dict(pk_name: str, pk_constraint_string: str) -> dict: - """Given a primary key name and a primary key constraint string, return a dictionary - with the following keys: - - constrained_columns - A list of string column names that make up the primary key - - name - The name of the primary key constraint - """ - - constrained_columns = _parse_pk_columns_from_constraint_string(pk_constraint_string) - - return {"constrained_columns": constrained_columns, "name": pk_name} - - -def match_dte_rows_by_value(dte_output: List[Dict[str, str]], match: str) -> List[dict]: - """Return a list of dictionaries containing only the col_name:data_type pairs where the `data_type` - value contains the match argument. - - Today, DESCRIBE TABLE EXTENDED doesn't give a deterministic name to the fields - a constraint will be found in its output. So we cycle through its output looking - for a match. This is brittle. We could optionally make two roundtrips: the first - would query information_schema for the name of the constraint on this table, and - a second to DESCRIBE TABLE EXTENDED, at which point we would know the name of the - constraint. But for now we instead assume that Python list comprehension is faster - than a network roundtrip - """ - - output_rows = [] - - for row_dict in dte_output: - if match in row_dict["data_type"]: - output_rows.append(row_dict) - - return output_rows - - -def match_dte_rows_by_key(dte_output: List[Dict[str, str]], match: str) -> List[dict]: - """Return a list of dictionaries containing only the col_name:data_type pairs where the `col_name` - value contains the match argument. - """ - - output_rows = [] - - for row_dict in dte_output: - if match in row_dict["col_name"]: - output_rows.append(row_dict) - - return output_rows - - -def get_fk_strings_from_dte_output(dte_output: List[Dict[str, str]]) -> List[dict]: - """If the DESCRIBE TABLE EXTENDED output contains foreign key constraints, return a list of dictionaries, - one dictionary per defined constraint - """ - - output = match_dte_rows_by_value(dte_output, "FOREIGN KEY") - - return output - - -def get_pk_strings_from_dte_output( - dte_output: List[Dict[str, str]] -) -> Optional[List[dict]]: - """If the DESCRIBE TABLE EXTENDED output contains primary key constraints, return a list of dictionaries, - one dictionary per defined constraint. - - Returns None if no primary key constraints are found. - """ - - output = match_dte_rows_by_value(dte_output, "PRIMARY KEY") - - return output - - -def get_comment_from_dte_output(dte_output: List[Dict[str, str]]) -> Optional[str]: - """Returns the value of the first "Comment" col_name data in dte_output""" - output = match_dte_rows_by_key(dte_output, "Comment") - if not output: - return None - else: - return output[0]["data_type"] - - -# The keys of this dictionary are the values we expect to see in a -# TGetColumnsRequest's .TYPE_NAME attribute. -# These are enumerated in ttypes.py as class TTypeId. -# TODO: confirm that all types in TTypeId are included here. -GET_COLUMNS_TYPE_MAP = { - "boolean": sqlalchemy.types.Boolean, - "smallint": sqlalchemy.types.SmallInteger, - "tinyint": type_overrides.TINYINT, - "int": sqlalchemy.types.Integer, - "bigint": sqlalchemy.types.BigInteger, - "float": sqlalchemy.types.Float, - "double": sqlalchemy.types.Float, - "string": sqlalchemy.types.String, - "varchar": sqlalchemy.types.String, - "char": sqlalchemy.types.String, - "binary": sqlalchemy.types.String, - "array": sqlalchemy.types.String, - "map": sqlalchemy.types.String, - "struct": sqlalchemy.types.String, - "uniontype": sqlalchemy.types.String, - "decimal": sqlalchemy.types.Numeric, - "timestamp": type_overrides.TIMESTAMP, - "timestamp_ntz": type_overrides.TIMESTAMP_NTZ, - "date": sqlalchemy.types.Date, -} - - -def parse_numeric_type_precision_and_scale(type_name_str): - """Return an intantiated sqlalchemy Numeric() type that preserves the precision and scale indicated - in the output from TGetColumnsRequest. - - type_name_str - The value of TGetColumnsReq.TYPE_NAME. - - If type_name_str is "DECIMAL(18,5) returns sqlalchemy.types.Numeric(18,5) - """ - - pattern = re.compile(r"DECIMAL\((\d+,\d+)\)") - match = re.search(pattern, type_name_str) - precision_and_scale = match.group(1) - precision, scale = tuple(precision_and_scale.split(",")) - - return sqlalchemy.types.Numeric(int(precision), int(scale)) - - -def parse_column_info_from_tgetcolumnsresponse(thrift_resp_row) -> ReflectedColumn: - """Returns a dictionary of the ReflectedColumn schema parsed from - a single of the result of a TGetColumnsRequest thrift RPC - """ - - pat = re.compile(r"^\w+") - - # This method assumes a valid TYPE_NAME field in the response. - # TODO: add error handling in case TGetColumnsResponse format changes - - _raw_col_type = re.search(pat, thrift_resp_row.TYPE_NAME).group(0).lower() # type: ignore - _col_type = GET_COLUMNS_TYPE_MAP[_raw_col_type] - - if _raw_col_type == "decimal": - final_col_type = parse_numeric_type_precision_and_scale( - thrift_resp_row.TYPE_NAME - ) - else: - final_col_type = _col_type - - # See comments about autoincrement in test_suite.py - # Since Databricks SQL doesn't currently support inline AUTOINCREMENT declarations - # the autoincrement must be manually declared with an Identity() construct in SQLAlchemy - # Other dialects can perform this extra Identity() step automatically. But that is not - # implemented in the Databricks dialect right now. So autoincrement is currently always False. - # It's not clear what IS_AUTO_INCREMENT in the thrift response actually reflects or whether - # it ever returns a `YES`. - - # Per the guidance in SQLAlchemy's docstrings, we prefer to not even include an autoincrement - # key in this dictionary. - this_column = { - "name": thrift_resp_row.COLUMN_NAME, - "type": final_col_type, - "nullable": bool(thrift_resp_row.NULLABLE), - "default": thrift_resp_row.COLUMN_DEF, - "comment": thrift_resp_row.REMARKS or None, - } - - # TODO: figure out how to return sqlalchemy.interfaces in a way that mypy respects - return this_column # type: ignore diff --git a/src/databricks/sqlalchemy/_types.py b/src/databricks/sqlalchemy/_types.py deleted file mode 100644 index 5fc14a7..0000000 --- a/src/databricks/sqlalchemy/_types.py +++ /dev/null @@ -1,323 +0,0 @@ -from datetime import datetime, time, timezone -from itertools import product -from typing import Any, Union, Optional - -import sqlalchemy -from sqlalchemy.engine.interfaces import Dialect -from sqlalchemy.ext.compiler import compiles - -from databricks.sql.utils import ParamEscaper - - -def process_literal_param_hack(value: Any): - """This method is supposed to accept a Python type and return a string representation of that type. - But due to some weirdness in the way SQLAlchemy's literal rendering works, we have to return - the value itself because, by the time it reaches our custom type code, it's already been converted - into a string. - - TimeTest - DateTimeTest - DateTimeTZTest - - This dynamic only seems to affect the literal rendering of datetime and time objects. - - All fail without this hack in-place. I'm not sure why. But it works. - """ - return value - - -@compiles(sqlalchemy.types.Enum, "databricks") -@compiles(sqlalchemy.types.String, "databricks") -@compiles(sqlalchemy.types.Text, "databricks") -@compiles(sqlalchemy.types.Time, "databricks") -@compiles(sqlalchemy.types.Unicode, "databricks") -@compiles(sqlalchemy.types.UnicodeText, "databricks") -@compiles(sqlalchemy.types.Uuid, "databricks") -def compile_string_databricks(type_, compiler, **kw): - """ - We override the default compilation for Enum(), String(), Text(), and Time() because SQLAlchemy - defaults to incompatible / abnormal compiled names - - Enum -> VARCHAR - String -> VARCHAR[LENGTH] - Text -> VARCHAR[LENGTH] - Time -> TIME - Unicode -> VARCHAR[LENGTH] - UnicodeText -> TEXT - Uuid -> CHAR[32] - - But all of these types will be compiled to STRING in Databricks SQL - """ - return "STRING" - - -@compiles(sqlalchemy.types.Integer, "databricks") -def compile_integer_databricks(type_, compiler, **kw): - """ - We need to override the default Integer compilation rendering because Databricks uses "INT" instead of "INTEGER" - """ - return "INT" - - -@compiles(sqlalchemy.types.LargeBinary, "databricks") -def compile_binary_databricks(type_, compiler, **kw): - """ - We need to override the default LargeBinary compilation rendering because Databricks uses "BINARY" instead of "BLOB" - """ - return "BINARY" - - -@compiles(sqlalchemy.types.Numeric, "databricks") -def compile_numeric_databricks(type_, compiler, **kw): - """ - We need to override the default Numeric compilation rendering because Databricks uses "DECIMAL" instead of "NUMERIC" - - The built-in visit_DECIMAL behaviour captures the precision and scale. Here we're just mapping calls to compile Numeric - to the SQLAlchemy Decimal() implementation - """ - return compiler.visit_DECIMAL(type_, **kw) - - -@compiles(sqlalchemy.types.DateTime, "databricks") -def compile_datetime_databricks(type_, compiler, **kw): - """ - We need to override the default DateTime compilation rendering because Databricks uses "TIMESTAMP_NTZ" instead of "DATETIME" - """ - return "TIMESTAMP_NTZ" - - -@compiles(sqlalchemy.types.ARRAY, "databricks") -def compile_array_databricks(type_, compiler, **kw): - """ - SQLAlchemy's default ARRAY can't compile as it's only implemented for Postgresql. - The Postgres implementation works for Databricks SQL, so we duplicate that here. - - :type_: - This is an instance of sqlalchemy.types.ARRAY which always includes an item_type attribute - which is itself an instance of TypeEngine - - https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.ARRAY - """ - - inner = compiler.process(type_.item_type, **kw) - - return f"ARRAY<{inner}>" - - -class TIMESTAMP_NTZ(sqlalchemy.types.TypeDecorator): - """Represents values comprising values of fields year, month, day, hour, minute, and second. - All operations are performed without taking any time zone into account. - - Our dialect maps sqlalchemy.types.DateTime() to this type, which means that all DateTime() - objects are stored without tzinfo. To read and write timezone-aware datetimes use - databricks.sql.TIMESTAMP instead. - - https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-ntz-type.html - """ - - impl = sqlalchemy.types.DateTime - - cache_ok = True - - def process_result_value(self, value: Union[None, datetime], dialect): - if value is None: - return None - return value.replace(tzinfo=None) - - -class TIMESTAMP(sqlalchemy.types.TypeDecorator): - """Represents values comprising values of fields year, month, day, hour, minute, and second, - with the session local time-zone. - - Our dialect maps sqlalchemy.types.DateTime() to TIMESTAMP_NTZ, which means that all DateTime() - objects are stored without tzinfo. To read and write timezone-aware datetimes use - this type instead. - - ```python - # This won't work - `Column(sqlalchemy.DateTime(timezone=True))` - - # But this does - `Column(TIMESTAMP)` - ```` - - https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-type.html - """ - - impl = sqlalchemy.types.DateTime - - cache_ok = True - - def process_result_value(self, value: Union[None, datetime], dialect): - if value is None: - return None - - if not value.tzinfo: - return value.replace(tzinfo=timezone.utc) - return value - - def process_bind_param( - self, value: Union[datetime, None], dialect - ) -> Optional[datetime]: - """pysql can pass datetime.datetime() objects directly to DBR""" - return value - - def process_literal_param( - self, value: Union[datetime, None], dialect: Dialect - ) -> str: - """ """ - return process_literal_param_hack(value) - - -@compiles(TIMESTAMP, "databricks") -def compile_timestamp_databricks(type_, compiler, **kw): - """ - We need to override the default DateTime compilation rendering because Databricks uses "TIMESTAMP_NTZ" instead of "DATETIME" - """ - return "TIMESTAMP" - - -class DatabricksTimeType(sqlalchemy.types.TypeDecorator): - """Databricks has no native TIME type. So we store it as a string.""" - - impl = sqlalchemy.types.Time - cache_ok = True - - BASE_FMT = "%H:%M:%S" - MICROSEC_PART = ".%f" - TIMEZONE_PART = "%z" - - def _generate_fmt_string(self, ms: bool, tz: bool) -> str: - """Return a format string for datetime.strptime() that includes or excludes microseconds and timezone.""" - _ = lambda x, y: x if y else "" - return f"{self.BASE_FMT}{_(self.MICROSEC_PART,ms)}{_(self.TIMEZONE_PART,tz)}" - - @property - def allowed_fmt_strings(self): - """Time strings can be read with or without microseconds and with or without a timezone.""" - - if not hasattr(self, "_allowed_fmt_strings"): - ms_switch = tz_switch = [True, False] - self._allowed_fmt_strings = [ - self._generate_fmt_string(x, y) - for x, y in product(ms_switch, tz_switch) - ] - - return self._allowed_fmt_strings - - def _parse_result_string(self, value: str) -> time: - """Parse a string into a time object. Try all allowed formats until one works.""" - for fmt in self.allowed_fmt_strings: - try: - # We use timetz() here because we want to preserve the timezone information - # Calling .time() will strip the timezone information - return datetime.strptime(value, fmt).timetz() - except ValueError: - pass - - raise ValueError(f"Could not parse time string {value}") - - def _determine_fmt_string(self, value: time) -> str: - """Determine which format string to use to render a time object as a string.""" - ms_bool = value.microsecond > 0 - tz_bool = value.tzinfo is not None - return self._generate_fmt_string(ms_bool, tz_bool) - - def process_bind_param(self, value: Union[time, None], dialect) -> Union[None, str]: - """Values sent to the database are converted to %:H:%M:%S strings.""" - if value is None: - return None - fmt_string = self._determine_fmt_string(value) - return value.strftime(fmt_string) - - # mypy doesn't like this workaround because TypeEngine wants process_literal_param to return a string - def process_literal_param(self, value, dialect) -> time: # type: ignore - """ """ - return process_literal_param_hack(value) - - def process_result_value( - self, value: Union[None, str], dialect - ) -> Union[time, None]: - """Values received from the database are parsed into datetime.time() objects""" - if value is None: - return None - - return self._parse_result_string(value) - - -class DatabricksStringType(sqlalchemy.types.TypeDecorator): - """We have to implement our own String() type because SQLAlchemy's default implementation - wants to escape single-quotes with a doubled single-quote. Databricks uses a backslash for - escaping of literal strings. And SQLAlchemy's default escaping breaks Databricks SQL. - """ - - impl = sqlalchemy.types.String - cache_ok = True - pe = ParamEscaper() - - def process_literal_param(self, value, dialect) -> str: - """SQLAlchemy's default string escaping for backslashes doesn't work for databricks. The logic here - implements the same logic as our legacy inline escaping logic. - """ - - return self.pe.escape_string(value) - - def literal_processor(self, dialect): - """We manually override this method to prevent further processing of the string literal beyond - what happens in the process_literal_param() method. - - The SQLAlchemy docs _specifically_ say to not override this method. - - It appears that any processing that happens from TypeEngine.process_literal_param happens _before_ - and _in addition to_ whatever the class's impl.literal_processor() method does. The String.literal_processor() - method performs a string replacement that doubles any single-quote in the contained string. This raises a syntax - error in Databricks. And it's not necessary because ParamEscaper() already implements all the escaping we need. - - We should consider opening an issue on the SQLAlchemy project to see if I'm using it wrong. - - See type_api.py::TypeEngine.literal_processor: - - ```python - def process(value: Any) -> str: - return fixed_impl_processor( - fixed_process_literal_param(value, dialect) - ) - ``` - - That call to fixed_impl_processor wraps the result of fixed_process_literal_param (which is the - process_literal_param defined in our Databricks dialect) - - https://docs.sqlalchemy.org/en/20/core/custom_types.html#sqlalchemy.types.TypeDecorator.literal_processor - """ - - def process(value): - """This is a copy of the default String.literal_processor() method but stripping away - its double-escaping behaviour for single-quotes. - """ - - _step1 = self.process_literal_param(value, dialect="databricks") - if dialect.identifier_preparer._double_percents: - _step2 = _step1.replace("%", "%%") - else: - _step2 = _step1 - - return "%s" % _step2 - - return process - - -class TINYINT(sqlalchemy.types.TypeDecorator): - """Represents 1-byte signed integers - - Acts like a sqlalchemy SmallInteger() in Python but writes to a TINYINT field in Databricks - - https://docs.databricks.com/en/sql/language-manual/data-types/tinyint-type.html - """ - - impl = sqlalchemy.types.SmallInteger - cache_ok = True - - -@compiles(TINYINT, "databricks") -def compile_tinyint(type_, compiler, **kw): - return "TINYINT" diff --git a/src/databricks/sqlalchemy/base.py b/src/databricks/sqlalchemy/base.py deleted file mode 100644 index 9148de7..0000000 --- a/src/databricks/sqlalchemy/base.py +++ /dev/null @@ -1,436 +0,0 @@ -from typing import Any, List, Optional, Dict, Union - -import databricks.sqlalchemy._ddl as dialect_ddl_impl -import databricks.sqlalchemy._types as dialect_type_impl -from databricks import sql -from databricks.sqlalchemy._parse import ( - _describe_table_extended_result_to_dict_list, - _match_table_not_found_string, - build_fk_dict, - build_pk_dict, - get_fk_strings_from_dte_output, - get_pk_strings_from_dte_output, - get_comment_from_dte_output, - parse_column_info_from_tgetcolumnsresponse, -) - -import sqlalchemy -from sqlalchemy import DDL, event -from sqlalchemy.engine import Connection, Engine, default, reflection -from sqlalchemy.engine.interfaces import ( - ReflectedForeignKeyConstraint, - ReflectedPrimaryKeyConstraint, - ReflectedColumn, - ReflectedTableComment, -) -from sqlalchemy.engine.reflection import ReflectionDefaults -from sqlalchemy.exc import DatabaseError, SQLAlchemyError - -try: - import alembic -except ImportError: - pass -else: - from alembic.ddl import DefaultImpl - - class DatabricksImpl(DefaultImpl): - __dialect__ = "databricks" - - -import logging - -logger = logging.getLogger(__name__) - - -class DatabricksDialect(default.DefaultDialect): - """This dialect implements only those methods required to pass our e2e tests""" - - # See sqlalchemy.engine.interfaces for descriptions of each of these properties - name: str = "databricks" - driver: str = "databricks" - default_schema_name: str = "default" - preparer = dialect_ddl_impl.DatabricksIdentifierPreparer # type: ignore - ddl_compiler = dialect_ddl_impl.DatabricksDDLCompiler - statement_compiler = dialect_ddl_impl.DatabricksStatementCompiler - supports_statement_cache: bool = True - supports_multivalues_insert: bool = True - supports_native_decimal: bool = True - supports_sane_rowcount: bool = False - non_native_boolean_check_constraint: bool = False - supports_identity_columns: bool = True - supports_schemas: bool = True - default_paramstyle: str = "named" - div_is_floordiv: bool = False - supports_default_values: bool = False - supports_server_side_cursors: bool = False - supports_sequences: bool = False - supports_native_boolean: bool = True - - colspecs = { - sqlalchemy.types.DateTime: dialect_type_impl.TIMESTAMP_NTZ, - sqlalchemy.types.Time: dialect_type_impl.DatabricksTimeType, - sqlalchemy.types.String: dialect_type_impl.DatabricksStringType, - } - - # SQLAlchemy requires that a table with no primary key - # constraint return a dictionary that looks like this. - EMPTY_PK: Dict[str, Any] = {"constrained_columns": [], "name": None} - - # SQLAlchemy requires that a table with no foreign keys - # defined return an empty list. Same for indexes. - EMPTY_FK: List - EMPTY_INDEX: List - EMPTY_FK = EMPTY_INDEX = [] - - @classmethod - def import_dbapi(cls): - return sql - - def _force_paramstyle_to_native_mode(self): - """This method can be removed after databricks-sql-connector wholly switches to NATIVE ParamApproach. - - This is a hack to trick SQLAlchemy into using a different paramstyle - than the one declared by this module in src/databricks/sql/__init__.py - - This method is called _after_ the dialect has been initialised, which is important because otherwise - our users would need to include a `paramstyle` argument in their SQLAlchemy connection string. - - This dialect is written to support NATIVE queries. Although the INLINE approach can technically work, - the same behaviour can be achieved within SQLAlchemy itself using its literal_processor methods. - """ - - self.paramstyle = self.default_paramstyle - - def create_connect_args(self, url): - # TODO: can schema be provided after HOST? - # Expected URI format is: databricks+thrift://token:dapi***@***.cloud.databricks.com?http_path=/sql/*** - - kwargs = { - "server_hostname": url.host, - "access_token": url.password, - "http_path": url.query.get("http_path"), - "catalog": url.query.get("catalog"), - "schema": url.query.get("schema"), - "use_inline_params": False, - } - - self.schema = kwargs["schema"] - self.catalog = kwargs["catalog"] - - self._force_paramstyle_to_native_mode() - - return [], kwargs - - def get_columns( - self, connection, table_name, schema=None, **kwargs - ) -> List[ReflectedColumn]: - """Return information about columns in `table_name`.""" - - with self.get_connection_cursor(connection) as cur: - resp = cur.columns( - catalog_name=self.catalog, - schema_name=schema or self.schema, - table_name=table_name, - ).fetchall() - - if not resp: - # TGetColumnsRequest will not raise an exception if passed a table that doesn't exist - # But Databricks supports tables with no columns. So if the result is an empty list, - # we need to check if the table exists (and raise an exception if not) or simply return - # an empty list. - self._describe_table_extended( - connection, - table_name, - self.catalog, - schema or self.schema, - expect_result=False, - ) - return resp - columns = [] - for col in resp: - row_dict = parse_column_info_from_tgetcolumnsresponse(col) - columns.append(row_dict) - - return columns - - def _describe_table_extended( - self, - connection: Connection, - table_name: str, - catalog_name: Optional[str] = None, - schema_name: Optional[str] = None, - expect_result=True, - ) -> Union[List[Dict[str, str]], None]: - """Run DESCRIBE TABLE EXTENDED on a table and return a list of dictionaries of the result. - - This method is the fastest way to check for the presence of a table in a schema. - - If expect_result is False, this method returns None as the output dict isn't required. - - Raises NoSuchTableError if the table is not present in the schema. - """ - - _target_catalog = catalog_name or self.catalog - _target_schema = schema_name or self.schema - _target = f"`{_target_catalog}`.`{_target_schema}`.`{table_name}`" - - # sql injection risk? - # DESCRIBE TABLE EXTENDED in DBR doesn't support parameterised inputs :( - stmt = DDL(f"DESCRIBE TABLE EXTENDED {_target}") - - try: - result = connection.execute(stmt) - except DatabaseError as e: - if _match_table_not_found_string(str(e)): - raise sqlalchemy.exc.NoSuchTableError( - f"No such table {table_name}" - ) from e - raise e - - if not expect_result: - return None - - fmt_result = _describe_table_extended_result_to_dict_list(result) - return fmt_result - - @reflection.cache - def get_pk_constraint( - self, - connection, - table_name: str, - schema: Optional[str] = None, - **kw: Any, - ) -> ReflectedPrimaryKeyConstraint: - """Fetch information about the primary key constraint on table_name. - - Returns a dictionary with these keys: - constrained_columns - a list of column names that make up the primary key. Results is an empty list - if no PRIMARY KEY is defined. - - name - the name of the primary key constraint - """ - - result = self._describe_table_extended( - connection=connection, - table_name=table_name, - schema_name=schema, - ) - - # Type ignore is because mypy knows that self._describe_table_extended *can* - # return None (even though it never will since expect_result defaults to True) - raw_pk_constraints: List = get_pk_strings_from_dte_output(result) # type: ignore - if not any(raw_pk_constraints): - return self.EMPTY_PK # type: ignore - - if len(raw_pk_constraints) > 1: - logger.warning( - "Found more than one primary key constraint in DESCRIBE TABLE EXTENDED output. " - "This is unexpected. Please report this as a bug. " - "Only the first primary key constraint will be returned." - ) - - first_pk_constraint = raw_pk_constraints[0] - pk_name = first_pk_constraint.get("col_name") - pk_constraint_string = first_pk_constraint.get("data_type") - - # TODO: figure out how to return sqlalchemy.interfaces in a way that mypy respects - return build_pk_dict(pk_name, pk_constraint_string) # type: ignore - - def get_foreign_keys( - self, connection, table_name, schema=None, **kw - ) -> List[ReflectedForeignKeyConstraint]: - """Return information about foreign_keys in `table_name`.""" - - result = self._describe_table_extended( - connection=connection, - table_name=table_name, - schema_name=schema, - ) - - # Type ignore is because mypy knows that self._describe_table_extended *can* - # return None (even though it never will since expect_result defaults to True) - raw_fk_constraints: List = get_fk_strings_from_dte_output(result) # type: ignore - - if not any(raw_fk_constraints): - return self.EMPTY_FK - - fk_constraints = [] - for constraint_dict in raw_fk_constraints: - fk_name = constraint_dict.get("col_name") - fk_constraint_string = constraint_dict.get("data_type") - this_constraint_dict = build_fk_dict( - fk_name, fk_constraint_string, schema_name=schema - ) - fk_constraints.append(this_constraint_dict) - - # TODO: figure out how to return sqlalchemy.interfaces in a way that mypy respects - return fk_constraints # type: ignore - - def get_indexes(self, connection, table_name, schema=None, **kw): - """SQLAlchemy requires this method. Databricks doesn't support indexes.""" - return self.EMPTY_INDEX - - @reflection.cache - def get_table_names(self, connection: Connection, schema=None, **kwargs): - """Return a list of tables in the current schema.""" - - _target_catalog = self.catalog - _target_schema = schema or self.schema - _target = f"`{_target_catalog}`.`{_target_schema}`" - - stmt = DDL(f"SHOW TABLES FROM {_target}") - - tables_result = connection.execute(stmt).all() - views_result = self.get_view_names(connection=connection, schema=schema) - - # In Databricks, SHOW TABLES FROM returns both tables and views. - # Potential optimisation: rewrite this to instead query information_schema - tables_minus_views = [ - row.tableName for row in tables_result if row.tableName not in views_result - ] - - return tables_minus_views - - @reflection.cache - def get_view_names( - self, - connection, - schema=None, - only_materialized=False, - only_temp=False, - **kwargs, - ) -> List[str]: - """Returns a list of string view names contained in the schema, if any.""" - - _target_catalog = self.catalog - _target_schema = schema or self.schema - _target = f"`{_target_catalog}`.`{_target_schema}`" - - stmt = DDL(f"SHOW VIEWS FROM {_target}") - result = connection.execute(stmt).all() - - return [ - row.viewName - for row in result - if (not only_materialized or row.isMaterialized) - and (not only_temp or row.isTemporary) - ] - - @reflection.cache - def get_materialized_view_names( - self, connection: Connection, schema: Optional[str] = None, **kw: Any - ) -> List[str]: - """A wrapper around get_view_names that fetches only the names of materialized views""" - return self.get_view_names(connection, schema, only_materialized=True) - - @reflection.cache - def get_temp_view_names( - self, connection: Connection, schema: Optional[str] = None, **kw: Any - ) -> List[str]: - """A wrapper around get_view_names that fetches only the names of temporary views""" - return self.get_view_names(connection, schema, only_temp=True) - - def do_rollback(self, dbapi_connection): - # Databricks SQL Does not support transactions - pass - - @reflection.cache - def has_table( - self, connection, table_name, schema=None, catalog=None, **kwargs - ) -> bool: - """For internal dialect use, check the existence of a particular table - or view in the database. - """ - - try: - self._describe_table_extended( - connection=connection, - table_name=table_name, - catalog_name=catalog, - schema_name=schema, - ) - return True - except sqlalchemy.exc.NoSuchTableError as e: - return False - - def get_connection_cursor(self, connection): - """Added for backwards compatibility with 1.3.x""" - if hasattr(connection, "_dbapi_connection"): - return connection._dbapi_connection.dbapi_connection.cursor() - elif hasattr(connection, "raw_connection"): - return connection.raw_connection().cursor() - elif hasattr(connection, "connection"): - return connection.connection.cursor() - - raise SQLAlchemyError( - "Databricks dialect can't obtain a cursor context manager from the dbapi" - ) - - @reflection.cache - def get_schema_names(self, connection, **kw): - """Return a list of all schema names available in the database.""" - stmt = DDL("SHOW SCHEMAS") - result = connection.execute(stmt) - schema_list = [row[0] for row in result] - return schema_list - - @reflection.cache - def get_table_comment( - self, - connection: Connection, - table_name: str, - schema: Optional[str] = None, - **kw: Any, - ) -> ReflectedTableComment: - result = self._describe_table_extended( - connection=connection, - table_name=table_name, - schema_name=schema, - ) - - if result is None: - return ReflectionDefaults.table_comment() - - comment = get_comment_from_dte_output(result) - - if comment: - return dict(text=comment) - else: - return ReflectionDefaults.table_comment() - - -@event.listens_for(Engine, "do_connect") -def receive_do_connect(dialect, conn_rec, cargs, cparams): - """Helpful for DS on traffic from clients using SQLAlchemy in particular""" - - # Ignore connect invocations that don't use our dialect - if not dialect.name == "databricks": - return - - ua = cparams.get("_user_agent_entry", "") - - def add_sqla_tag_if_not_present(val: str): - if not val: - output = "sqlalchemy" - - if val and "sqlalchemy" in val: - output = val - - else: - output = f"sqlalchemy + {val}" - - return output - - cparams["_user_agent_entry"] = add_sqla_tag_if_not_present(ua) - - if sqlalchemy.__version__.startswith("1.3"): - # SQLAlchemy 1.3.x fails to parse the http_path, catalog, and schema from our connection string - # These should be passed in as connect_args when building the Engine - - if "schema" in cparams: - dialect.schema = cparams["schema"] - - if "catalog" in cparams: - dialect.catalog = cparams["catalog"] diff --git a/src/databricks/sqlalchemy/dependency_test/test_dependency.py b/src/databricks/sqlalchemy/dependency_test/test_dependency.py deleted file mode 100644 index 7cb59e8..0000000 --- a/src/databricks/sqlalchemy/dependency_test/test_dependency.py +++ /dev/null @@ -1,22 +0,0 @@ -import pytest - -class DatabricksImportError(Exception): - pass - -class TestLibraryDependencySuite: - - @pytest.mark.skipif(pytest.importorskip("databricks_sql_connector_core"), reason="databricks_sql_connector_core is present") - def test_sql_core(self): - with pytest.raises(DatabricksImportError, match="databricks_sql_connector_core module is not available"): - try: - import databricks - except ImportError: - raise DatabricksImportError("databricks_sql_connector_core module is not available") - - @pytest.mark.skipif(pytest.importorskip("sqlalchemy"), reason="SQLAlchemy is present") - def test_sqlalchemy(self): - with pytest.raises(DatabricksImportError, match="sqlalchemy module is not available"): - try: - import sqlalchemy - except ImportError: - raise DatabricksImportError("sqlalchemy module is not available") \ No newline at end of file diff --git a/src/databricks/sqlalchemy/dialect/__init__.py b/src/databricks/sqlalchemy/dialect/__init__.py new file mode 100644 index 0000000..a1020a7 --- /dev/null +++ b/src/databricks/sqlalchemy/dialect/__init__.py @@ -0,0 +1,340 @@ +"""This module's layout loosely follows example of SQLAlchemy's postgres dialect +""" + +import decimal, re, datetime +from dateutil.parser import parse + +import sqlalchemy +from sqlalchemy import types, event +from sqlalchemy.engine import default, Engine +from sqlalchemy.exc import DatabaseError, SQLAlchemyError +from sqlalchemy.engine import reflection + +from databricks import sql + + +from databricks.sqlalchemy.dialect.base import ( + DatabricksDDLCompiler, + DatabricksIdentifierPreparer, +) +from databricks.sqlalchemy.dialect.compiler import DatabricksTypeCompiler + +try: + import alembic +except ImportError: + pass +else: + from alembic.ddl import DefaultImpl + + class DatabricksImpl(DefaultImpl): + __dialect__ = "databricks" + + +class DatabricksDecimal(types.TypeDecorator): + """Translates strings to decimals""" + + impl = types.DECIMAL + + def process_result_value(self, value, dialect): + if value is not None: + return decimal.Decimal(value) + else: + return None + + +class DatabricksTimestamp(types.TypeDecorator): + """Translates timestamp strings to datetime objects""" + + impl = types.TIMESTAMP + + def process_result_value(self, value, dialect): + return value + + def adapt(self, impltype, **kwargs): + return self.impl + + +class DatabricksDate(types.TypeDecorator): + """Translates date strings to date objects""" + + impl = types.DATE + + def process_result_value(self, value, dialect): + return value + + def adapt(self, impltype, **kwargs): + return self.impl + + +class DatabricksDialect(default.DefaultDialect): + """This dialect implements only those methods required to pass our e2e tests""" + + # Possible attributes are defined here: https://docs.sqlalchemy.org/en/14/core/internals.html#sqlalchemy.engine.Dialect + name: str = "databricks" + driver: str = "databricks-sql-python" + default_schema_name: str = "default" + + preparer = DatabricksIdentifierPreparer # type: ignore + type_compiler = DatabricksTypeCompiler + ddl_compiler = DatabricksDDLCompiler + supports_statement_cache: bool = True + supports_multivalues_insert: bool = True + supports_native_decimal: bool = True + supports_sane_rowcount: bool = False + non_native_boolean_check_constraint: bool = False + + @classmethod + def dbapi(cls): + return sql + + def create_connect_args(self, url): + # TODO: can schema be provided after HOST? + # Expected URI format is: databricks+thrift://token:dapi***@***.cloud.databricks.com?http_path=/sql/*** + + kwargs = { + "server_hostname": url.host, + "access_token": url.password, + "http_path": url.query.get("http_path"), + "catalog": url.query.get("catalog"), + "schema": url.query.get("schema"), + } + + self.schema = kwargs["schema"] + self.catalog = kwargs["catalog"] + + return [], kwargs + + def get_columns(self, connection, table_name, schema=None, **kwargs): + """Return information about columns in `table_name`. + + Given a :class:`_engine.Connection`, a string + `table_name`, and an optional string `schema`, return column + information as a list of dictionaries with these keys: + + name + the column's name + + type + [sqlalchemy.types#TypeEngine] + + nullable + boolean + + default + the column's default value + + autoincrement + boolean + + sequence + a dictionary of the form + {'name' : str, 'start' :int, 'increment': int, 'minvalue': int, + 'maxvalue': int, 'nominvalue': bool, 'nomaxvalue': bool, + 'cycle': bool, 'cache': int, 'order': bool} + + Additional column attributes may be present. + """ + + _type_map = { + "boolean": types.Boolean, + "smallint": types.SmallInteger, + "int": types.Integer, + "bigint": types.BigInteger, + "float": types.Float, + "double": types.Float, + "string": types.String, + "varchar": types.String, + "char": types.String, + "binary": types.String, + "array": types.String, + "map": types.String, + "struct": types.String, + "uniontype": types.String, + "decimal": DatabricksDecimal, + "timestamp": DatabricksTimestamp, + "date": DatabricksDate, + } + + with self.get_connection_cursor(connection) as cur: + resp = cur.columns( + catalog_name=self.catalog, + schema_name=schema or self.schema, + table_name=table_name, + ).fetchall() + + columns = [] + + for col in resp: + + # Taken from PyHive. This removes added type info from decimals and maps + _col_type = re.search(r"^\w+", col.TYPE_NAME).group(0) + this_column = { + "name": col.COLUMN_NAME, + "type": _type_map[_col_type.lower()], + "nullable": bool(col.NULLABLE), + "default": col.COLUMN_DEF, + "autoincrement": False if col.IS_AUTO_INCREMENT == "NO" else True, + } + columns.append(this_column) + + return columns + + def get_pk_constraint(self, connection, table_name, schema=None, **kw): + """Return information about the primary key constraint on + table_name`. + + Given a :class:`_engine.Connection`, a string + `table_name`, and an optional string `schema`, return primary + key information as a dictionary with these keys: + + constrained_columns + a list of column names that make up the primary key + + name + optional name of the primary key constraint. + + """ + # TODO: implement this behaviour + return {"constrained_columns": []} + + def get_foreign_keys(self, connection, table_name, schema=None, **kw): + """Return information about foreign_keys in `table_name`. + + Given a :class:`_engine.Connection`, a string + `table_name`, and an optional string `schema`, return foreign + key information as a list of dicts with these keys: + + name + the constraint's name + + constrained_columns + a list of column names that make up the foreign key + + referred_schema + the name of the referred schema + + referred_table + the name of the referred table + + referred_columns + a list of column names in the referred table that correspond to + constrained_columns + """ + # TODO: Implement this behaviour + return [] + + def get_indexes(self, connection, table_name, schema=None, **kw): + """Return information about indexes in `table_name`. + + Given a :class:`_engine.Connection`, a string + `table_name` and an optional string `schema`, return index + information as a list of dictionaries with these keys: + + name + the index's name + + column_names + list of column names in order + + unique + boolean + """ + # TODO: Implement this behaviour + return [] + + def get_table_names(self, connection, schema=None, **kwargs): + TABLE_NAME = 1 + with self.get_connection_cursor(connection) as cur: + sql_str = "SHOW TABLES FROM {}".format( + ".".join([self.catalog, schema or self.schema]) + ) + data = cur.execute(sql_str).fetchall() + _tables = [i[TABLE_NAME] for i in data] + + return _tables + + def get_view_names(self, connection, schema=None, **kwargs): + VIEW_NAME = 1 + with self.get_connection_cursor(connection) as cur: + sql_str = "SHOW VIEWS FROM {}".format( + ".".join([self.catalog, schema or self.schema]) + ) + data = cur.execute(sql_str).fetchall() + _tables = [i[VIEW_NAME] for i in data] + + return _tables + + def do_rollback(self, dbapi_connection): + # Databricks SQL Does not support transactions + pass + + def has_table( + self, connection, table_name, schema=None, catalog=None, **kwargs + ) -> bool: + """SQLAlchemy docstrings say dialect providers must implement this method""" + + _schema = schema or self.schema + _catalog = catalog or self.catalog + + # DBR >12.x uses underscores in error messages + DBR_LTE_12_NOT_FOUND_STRING = "Table or view not found" + DBR_GT_12_NOT_FOUND_STRING = "TABLE_OR_VIEW_NOT_FOUND" + + try: + res = connection.execute( + f"DESCRIBE TABLE {_catalog}.{_schema}.{table_name}" + ) + return True + except DatabaseError as e: + if DBR_GT_12_NOT_FOUND_STRING in str( + e + ) or DBR_LTE_12_NOT_FOUND_STRING in str(e): + return False + else: + raise e + + def get_connection_cursor(self, connection): + """Added for backwards compatibility with 1.3.x""" + if hasattr(connection, "_dbapi_connection"): + return connection._dbapi_connection.dbapi_connection.cursor() + elif hasattr(connection, "raw_connection"): + return connection.raw_connection().cursor() + elif hasattr(connection, "connection"): + return connection.connection.cursor() + + raise SQLAlchemyError( + "Databricks dialect can't obtain a cursor context manager from the dbapi" + ) + + @reflection.cache + def get_schema_names(self, connection, **kw): + # Equivalent to SHOW DATABASES + + # TODO: replace with call to cursor.schemas() once its performance matches raw SQL + return [row[0] for row in connection.execute("SHOW SCHEMAS")] + + +@event.listens_for(Engine, "do_connect") +def receive_do_connect(dialect, conn_rec, cargs, cparams): + """Helpful for DS on traffic from clients using SQLAlchemy in particular""" + + # Ignore connect invocations that don't use our dialect + if not dialect.name == "databricks": + return + + if "_user_agent_entry" in cparams: + new_user_agent = f"sqlalchemy + {cparams['_user_agent_entry']}" + else: + new_user_agent = "sqlalchemy" + + cparams["_user_agent_entry"] = new_user_agent + + if sqlalchemy.__version__.startswith("1.3"): + # SQLAlchemy 1.3.x fails to parse the http_path, catalog, and schema from our connection string + # These should be passed in as connect_args when building the Engine + + if "schema" in cparams: + dialect.schema = cparams["schema"] + + if "catalog" in cparams: + dialect.catalog = cparams["catalog"] diff --git a/src/databricks/sqlalchemy/dialect/base.py b/src/databricks/sqlalchemy/dialect/base.py new file mode 100644 index 0000000..080f041 --- /dev/null +++ b/src/databricks/sqlalchemy/dialect/base.py @@ -0,0 +1,17 @@ +import re +from sqlalchemy.sql import compiler + + +class DatabricksIdentifierPreparer(compiler.IdentifierPreparer): + # SparkSQL identifier specification: + # ref: https://spark.apache.org/docs/latest/sql-ref-identifier.html + + legal_characters = re.compile(r"^[A-Z0-9_]+$", re.I) + + def __init__(self, dialect): + super().__init__(dialect, initial_quote="`") + + +class DatabricksDDLCompiler(compiler.DDLCompiler): + def post_create_table(self, table): + return " USING DELTA" diff --git a/src/databricks/sqlalchemy/dialect/compiler.py b/src/databricks/sqlalchemy/dialect/compiler.py new file mode 100644 index 0000000..f77807e --- /dev/null +++ b/src/databricks/sqlalchemy/dialect/compiler.py @@ -0,0 +1,38 @@ +from sqlalchemy.sql import compiler + + +class DatabricksTypeCompiler(compiler.GenericTypeCompiler): + """Originally forked from pyhive""" + + def visit_INTEGER(self, type_): + return "INT" + + def visit_NUMERIC(self, type_): + return "DECIMAL" + + def visit_CHAR(self, type_): + return "STRING" + + def visit_VARCHAR(self, type_): + return "STRING" + + def visit_NCHAR(self, type_): + return "STRING" + + def visit_TEXT(self, type_): + return "STRING" + + def visit_CLOB(self, type_): + return "STRING" + + def visit_BLOB(self, type_): + return "BINARY" + + def visit_TIME(self, type_): + return "TIMESTAMP" + + def visit_DATE(self, type_): + return "DATE" + + def visit_DATETIME(self, type_): + return "TIMESTAMP" diff --git a/src/databricks/sqlalchemy/py.typed b/src/databricks/sqlalchemy/py.typed deleted file mode 100755 index e69de29..0000000 diff --git a/src/databricks/sqlalchemy/pytest.ini b/src/databricks/sqlalchemy/pytest.ini deleted file mode 100644 index ab89d17..0000000 --- a/src/databricks/sqlalchemy/pytest.ini +++ /dev/null @@ -1,4 +0,0 @@ - -[sqla_testing] -requirement_cls=databricks.sqlalchemy.requirements:Requirements -profile_file=profiles.txt diff --git a/src/databricks/sqlalchemy/requirements.py b/src/databricks/sqlalchemy/requirements.py deleted file mode 100644 index 5c70c02..0000000 --- a/src/databricks/sqlalchemy/requirements.py +++ /dev/null @@ -1,249 +0,0 @@ -""" -The complete list of requirements is provided by SQLAlchemy here: - -https://github.com/sqlalchemy/sqlalchemy/blob/main/lib/sqlalchemy/testing/requirements.py - -When SQLAlchemy skips a test because a requirement is closed() it gives a generic skip message. -To make these failures more actionable, we only define requirements in this file that we wish to -force to be open(). If a test should be skipped on Databricks, it will be specifically marked skip -in test_suite.py with a Databricks-specific reason. - -See the special note about the array_type exclusion below. -See special note about has_temp_table exclusion below. -""" - -import sqlalchemy.testing.requirements -import sqlalchemy.testing.exclusions - - -class Requirements(sqlalchemy.testing.requirements.SuiteRequirements): - @property - def date_historic(self): - """target dialect supports representation of Python - datetime.datetime() objects with historic (pre 1970) values.""" - - return sqlalchemy.testing.exclusions.open() - - @property - def datetime_historic(self): - """target dialect supports representation of Python - datetime.datetime() objects with historic (pre 1970) values.""" - - return sqlalchemy.testing.exclusions.open() - - @property - def datetime_literals(self): - """target dialect supports rendering of a date, time, or datetime as a - literal string, e.g. via the TypeEngine.literal_processor() method. - - """ - - return sqlalchemy.testing.exclusions.open() - - @property - def timestamp_microseconds(self): - """target dialect supports representation of Python - datetime.datetime() with microsecond objects but only - if TIMESTAMP is used.""" - - return sqlalchemy.testing.exclusions.open() - - @property - def time_microseconds(self): - """target dialect supports representation of Python - datetime.time() with microsecond objects. - - This requirement declaration isn't needed but I've included it here for completeness. - Since Databricks doesn't have a TIME type, SQLAlchemy will compile Time() columns - as STRING Databricks data types. And we use a custom time type to render those strings - between str() and time.time() representations. Therefore we can store _any_ precision - that SQLAlchemy needs. The time_microseconds requirement defaults to ON for all dialects - except mssql, mysql, mariadb, and oracle. - """ - - return sqlalchemy.testing.exclusions.open() - - @property - def infinity_floats(self): - """The Float type can persist and load float('inf'), float('-inf').""" - - return sqlalchemy.testing.exclusions.open() - - @property - def precision_numerics_retains_significant_digits(self): - """A precision numeric type will return empty significant digits, - i.e. a value such as 10.000 will come back in Decimal form with - the .000 maintained.""" - - return sqlalchemy.testing.exclusions.open() - - @property - def precision_numerics_many_significant_digits(self): - """target backend supports values with many digits on both sides, - such as 319438950232418390.273596, 87673.594069654243 - - """ - return sqlalchemy.testing.exclusions.open() - - @property - def array_type(self): - """While Databricks does support ARRAY types, pysql cannot bind them. So - we cannot use them with SQLAlchemy - - Due to a bug in SQLAlchemy, we _must_ define this exclusion as closed() here or else the - test runner will crash the pytest process due to an AttributeError - """ - - # TODO: Implement array type using inline? - return sqlalchemy.testing.exclusions.closed() - - @property - def table_ddl_if_exists(self): - """target platform supports IF NOT EXISTS / IF EXISTS for tables.""" - - return sqlalchemy.testing.exclusions.open() - - @property - def identity_columns(self): - """If a backend supports GENERATED { ALWAYS | BY DEFAULT } - AS IDENTITY""" - return sqlalchemy.testing.exclusions.open() - - @property - def identity_columns_standard(self): - """If a backend supports GENERATED { ALWAYS | BY DEFAULT } - AS IDENTITY with a standard syntax. - This is mainly to exclude MSSql. - """ - return sqlalchemy.testing.exclusions.open() - - @property - def has_temp_table(self): - """target dialect supports checking a single temp table name - - unfortunately this is not the same as temp_table_names - - SQLAlchemy's HasTableTest is not normalised in such a way that temp table tests - are separate from temp view and normal table tests. If those tests were split out, - we would just add detailed skip markers in test_suite.py. But since we'd like to - run the HasTableTest group for the features we support, we must set this exclusinon - to closed(). - - It would be ideal if there were a separate requirement for has_temp_view. Without it, - we're in a bind. - """ - return sqlalchemy.testing.exclusions.closed() - - @property - def temporary_views(self): - """target database supports temporary views""" - return sqlalchemy.testing.exclusions.open() - - @property - def views(self): - """Target database must support VIEWs.""" - - return sqlalchemy.testing.exclusions.open() - - @property - def temporary_tables(self): - """target database supports temporary tables - - ComponentReflection test is intricate and simply cannot function without this exclusion being defined here. - This happens because we cannot skip individual combinations used in ComponentReflection test. - """ - return sqlalchemy.testing.exclusions.closed() - - @property - def table_reflection(self): - """target database has general support for table reflection""" - return sqlalchemy.testing.exclusions.open() - - @property - def comment_reflection(self): - """Indicates if the database support table comment reflection""" - return sqlalchemy.testing.exclusions.open() - - @property - def comment_reflection_full_unicode(self): - """Indicates if the database support table comment reflection in the - full unicode range, including emoji etc. - """ - return sqlalchemy.testing.exclusions.open() - - @property - def temp_table_reflection(self): - """ComponentReflection test is intricate and simply cannot function without this exclusion being defined here. - This happens because we cannot skip individual combinations used in ComponentReflection test. - """ - return sqlalchemy.testing.exclusions.closed() - - @property - def index_reflection(self): - """ComponentReflection test is intricate and simply cannot function without this exclusion being defined here. - This happens because we cannot skip individual combinations used in ComponentReflection test. - """ - return sqlalchemy.testing.exclusions.closed() - - @property - def unique_constraint_reflection(self): - """ComponentReflection test is intricate and simply cannot function without this exclusion being defined here. - This happens because we cannot skip individual combinations used in ComponentReflection test. - - Databricks doesn't support UNIQUE constraints. - """ - return sqlalchemy.testing.exclusions.closed() - - @property - def reflects_pk_names(self): - """Target driver reflects the name of primary key constraints.""" - - return sqlalchemy.testing.exclusions.open() - - @property - def datetime_implicit_bound(self): - """target dialect when given a datetime object will bind it such - that the database server knows the object is a date, and not - a plain string. - """ - - return sqlalchemy.testing.exclusions.open() - - @property - def tuple_in(self): - return sqlalchemy.testing.exclusions.open() - - @property - def ctes(self): - return sqlalchemy.testing.exclusions.open() - - @property - def ctes_with_update_delete(self): - return sqlalchemy.testing.exclusions.open() - - @property - def delete_from(self): - """Target must support DELETE FROM..FROM or DELETE..USING syntax""" - return sqlalchemy.testing.exclusions.open() - - @property - def table_value_constructor(self): - return sqlalchemy.testing.exclusions.open() - - @property - def reflect_tables_no_columns(self): - return sqlalchemy.testing.exclusions.open() - - @property - def denormalized_names(self): - """Target database must have 'denormalized', i.e. - UPPERCASE as case insensitive names.""" - - return sqlalchemy.testing.exclusions.open() - - @property - def time_timezone(self): - """target dialect supports representation of Python - datetime.time() with tzinfo with Time(timezone=True).""" - - return sqlalchemy.testing.exclusions.open() diff --git a/src/databricks/sqlalchemy/setup.cfg b/src/databricks/sqlalchemy/setup.cfg deleted file mode 100644 index ab89d17..0000000 --- a/src/databricks/sqlalchemy/setup.cfg +++ /dev/null @@ -1,4 +0,0 @@ - -[sqla_testing] -requirement_cls=databricks.sqlalchemy.requirements:Requirements -profile_file=profiles.txt diff --git a/src/databricks/sqlalchemy/test/_extra.py b/src/databricks/sqlalchemy/test/_extra.py deleted file mode 100644 index 2f3e7a7..0000000 --- a/src/databricks/sqlalchemy/test/_extra.py +++ /dev/null @@ -1,70 +0,0 @@ -"""Additional tests authored by Databricks that use SQLAlchemy's test fixtures -""" - -import datetime - -from sqlalchemy.testing.suite.test_types import ( - _LiteralRoundTripFixture, - fixtures, - testing, - eq_, - select, - Table, - Column, - config, - _DateFixture, - literal, -) -from databricks.sqlalchemy import TINYINT, TIMESTAMP - - -class TinyIntegerTest(_LiteralRoundTripFixture, fixtures.TestBase): - __backend__ = True - - def test_literal(self, literal_round_trip): - literal_round_trip(TINYINT, [5], [5]) - - @testing.fixture - def integer_round_trip(self, metadata, connection): - def run(datatype, data): - int_table = Table( - "tiny_integer_table", - metadata, - Column( - "id", - TINYINT, - primary_key=True, - test_needs_autoincrement=False, - ), - Column("tiny_integer_data", datatype), - ) - - metadata.create_all(config.db) - - connection.execute(int_table.insert(), {"id": 1, "integer_data": data}) - - row = connection.execute(select(int_table.c.integer_data)).first() - - eq_(row, (data,)) - - assert isinstance(row[0], int) - - return run - - -class DateTimeTZTestCustom(_DateFixture, fixtures.TablesTest): - """This test confirms that when a user uses the TIMESTAMP - type to store a datetime object, it retains its timezone - """ - - __backend__ = True - datatype = TIMESTAMP - data = datetime.datetime(2012, 10, 15, 12, 57, 18, tzinfo=datetime.timezone.utc) - - @testing.requires.datetime_implicit_bound - def test_select_direct(self, connection): - - # We need to pass the TIMESTAMP type to the literal function - # so that the value is processed correctly. - result = connection.scalar(select(literal(self.data, TIMESTAMP))) - eq_(result, self.data) diff --git a/src/databricks/sqlalchemy/test/_future.py b/src/databricks/sqlalchemy/test/_future.py deleted file mode 100644 index 6e470f6..0000000 --- a/src/databricks/sqlalchemy/test/_future.py +++ /dev/null @@ -1,331 +0,0 @@ -# type: ignore - -from enum import Enum - -import pytest -from databricks.sqlalchemy.test._regression import ( - ExpandingBoundInTest, - IdentityAutoincrementTest, - LikeFunctionsTest, - NormalizedNameTest, -) -from databricks.sqlalchemy.test._unsupported import ( - ComponentReflectionTest, - ComponentReflectionTestExtra, - CTETest, - InsertBehaviorTest, -) -from sqlalchemy.testing.suite import ( - ArrayTest, - BinaryTest, - BizarroCharacterFKResolutionTest, - CollateTest, - ComputedColumnTest, - ComputedReflectionTest, - DifficultParametersTest, - FutureWeCanSetDefaultSchemaWEventsTest, - IdentityColumnTest, - IdentityReflectionTest, - JSONLegacyStringCastIndexTest, - JSONTest, - NativeUUIDTest, - QuotedNameArgumentTest, - RowCountTest, - SimpleUpdateDeleteTest, - WeCanSetDefaultSchemaWEventsTest, -) - - -class FutureFeature(Enum): - ARRAY = "ARRAY column type handling" - BINARY = "BINARY column type handling" - CHECK = "CHECK constraint handling" - COLLATE = "COLLATE DDL generation" - CTE_FEAT = "required CTE features" - EMPTY_INSERT = "empty INSERT support" - FK_OPTS = "foreign key option checking" - GENERATED_COLUMNS = "Delta computed / generated columns support" - IDENTITY = "identity reflection" - JSON = "JSON column type handling" - MULTI_PK = "get_multi_pk_constraint method" - PROVISION = "event-driven engine configuration" - REGEXP = "_visit_regexp" - SANE_ROWCOUNT = "sane_rowcount support" - TBL_OPTS = "get_table_options method" - TEST_DESIGN = "required test-fixture overrides" - TUPLE_LITERAL = "tuple-like IN markers completely" - UUID = "native Uuid() type" - VIEW_DEF = "get_view_definition method" - - -def render_future_feature(rsn: FutureFeature, extra=False) -> str: - postfix = " More detail in _future.py" if extra else "" - return f"[FUTURE][{rsn.name}]: This dialect doesn't implement {rsn.value}.{postfix}" - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.BINARY)) -class BinaryTest(BinaryTest): - """Databricks doesn't support binding of BINARY type values. When DBR supports this, we can implement - in this dialect. - """ - - pass - - -class ExpandingBoundInTest(ExpandingBoundInTest): - @pytest.mark.skip(render_future_feature(FutureFeature.TUPLE_LITERAL)) - def test_empty_heterogeneous_tuples_bindparam(self): - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.TUPLE_LITERAL)) - def test_empty_heterogeneous_tuples_direct(self): - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.TUPLE_LITERAL)) - def test_empty_homogeneous_tuples_bindparam(self): - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.TUPLE_LITERAL)) - def test_empty_homogeneous_tuples_direct(self): - pass - - -class NormalizedNameTest(NormalizedNameTest): - @pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN, True)) - def test_get_table_names(self): - """I'm not clear how this test can ever pass given that it's assertion looks like this: - - ```python - eq_(tablenames[0].upper(), tablenames[0].lower()) - eq_(tablenames[1].upper(), tablenames[1].lower()) - ``` - - It's forcibly calling .upper() and .lower() on the same string and expecting them to be equal. - """ - pass - - -class CTETest(CTETest): - @pytest.mark.skip(render_future_feature(FutureFeature.CTE_FEAT, True)) - def test_delete_from_round_trip(self): - """Databricks dialect doesn't implement multiple-table criteria within DELETE""" - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN, True)) -class IdentityColumnTest(IdentityColumnTest): - """Identity works. Test needs rewrite for Databricks. See comments in test_suite.py - - The setup for these tests tries to create a table with a DELTA IDENTITY column but has two problems: - 1. It uses an Integer() type for the column. Whereas DELTA IDENTITY columns must be BIGINT. - 2. It tries to set the start == 42, which Databricks doesn't support - - I can get the tests to _run_ by patching the table fixture to use BigInteger(). But it asserts that the - identity of two rows are 42 and 43, which is not possible since they will be rows 1 and 2 instead. - - I'm satisified through manual testing that our implementation of visit_identity_column works but a better test is needed. - """ - - pass - - -class IdentityAutoincrementTest(IdentityAutoincrementTest): - @pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN, True)) - def test_autoincrement_with_identity(self): - """This test has the same issue as IdentityColumnTest.test_select_all in that it creates a table with identity - using an Integer() rather than a BigInteger(). If I override this behaviour to use a BigInteger() instead, the - test passes. - """ - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN)) -class BizarroCharacterFKResolutionTest(BizarroCharacterFKResolutionTest): - """Some of the combinations in this test pass. Others fail. Given the esoteric nature of these failures, - we have opted to defer implementing fixes to a later time, guided by customer feedback. Passage of - these tests is not an acceptance criteria for our dialect. - """ - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN)) -class DifficultParametersTest(DifficultParametersTest): - """Some of the combinations in this test pass. Others fail. Given the esoteric nature of these failures, - we have opted to defer implementing fixes to a later time, guided by customer feedback. Passage of - these tests is not an acceptance criteria for our dialect. - """ - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.IDENTITY, True)) -class IdentityReflectionTest(IdentityReflectionTest): - """It's not clear _how_ to implement this for SQLAlchemy. Columns created with GENERATED ALWAYS AS IDENTITY - are not specially demarked in the output of TGetColumnsResponse or DESCRIBE TABLE EXTENDED. - - We could theoretically parse this from the contents of `SHOW CREATE TABLE` but that feels like a hack. - """ - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.JSON)) -class JSONTest(JSONTest): - """Databricks supports JSON path expressions in queries it's just not implemented in this dialect.""" - - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.JSON)) -class JSONLegacyStringCastIndexTest(JSONLegacyStringCastIndexTest): - """Same comment applies as JSONTest""" - - pass - - -class LikeFunctionsTest(LikeFunctionsTest): - @pytest.mark.skip(render_future_feature(FutureFeature.REGEXP)) - def test_not_regexp_match(self): - """The defaul dialect doesn't implement _visit_regexp methods so we don't get them automatically.""" - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.REGEXP)) - def test_regexp_match(self): - """The defaul dialect doesn't implement _visit_regexp methods so we don't get them automatically.""" - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.COLLATE)) -class CollateTest(CollateTest): - """This is supported in Databricks. Not implemented here.""" - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.UUID, True)) -class NativeUUIDTest(NativeUUIDTest): - """Type implementation will be straightforward. Since Databricks doesn't have a native UUID type we can use - a STRING field, create a custom TypeDecorator for sqlalchemy.types.Uuid and add it to the dialect's colspecs. - - Then mark requirements.uuid_data_type as open() so this test can run. - """ - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.SANE_ROWCOUNT)) -class RowCountTest(RowCountTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.SANE_ROWCOUNT)) -class SimpleUpdateDeleteTest(SimpleUpdateDeleteTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.PROVISION, True)) -class WeCanSetDefaultSchemaWEventsTest(WeCanSetDefaultSchemaWEventsTest): - """provision.py allows us to define event listeners that emit DDL for things like setting up a test schema - or, in this case, changing the default schema for the connection after it's been built. This would override - the schema defined in the sqlalchemy connection string. This support is possible but is not implemented - in the dialect. Deferred for now. - """ - - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.PROVISION, True)) -class FutureWeCanSetDefaultSchemaWEventsTest(FutureWeCanSetDefaultSchemaWEventsTest): - """provision.py allows us to define event listeners that emit DDL for things like setting up a test schema - or, in this case, changing the default schema for the connection after it's been built. This would override - the schema defined in the sqlalchemy connection string. This support is possible but is not implemented - in the dialect. Deferred for now. - """ - - pass - - -class ComponentReflectionTest(ComponentReflectionTest): - @pytest.mark.skip(reason=render_future_feature(FutureFeature.TBL_OPTS, True)) - def test_multi_get_table_options_tables(self): - """It's not clear what the expected ouput from this method would even _be_. Requires research.""" - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.VIEW_DEF)) - def test_get_view_definition(self): - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.VIEW_DEF)) - def test_get_view_definition_does_not_exist(self): - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.MULTI_PK)) - def test_get_multi_pk_constraint(self): - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.CHECK)) - def test_get_multi_check_constraints(self): - pass - - -class ComponentReflectionTestExtra(ComponentReflectionTestExtra): - @pytest.mark.skip(render_future_feature(FutureFeature.CHECK)) - def test_get_check_constraints(self): - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.FK_OPTS)) - def test_get_foreign_key_options(self): - """It's not clear from the test code what the expected output is here. Further research required.""" - pass - - -class InsertBehaviorTest(InsertBehaviorTest): - @pytest.mark.skip(render_future_feature(FutureFeature.EMPTY_INSERT, True)) - def test_empty_insert(self): - """Empty inserts are possible using DEFAULT VALUES on Databricks. To implement it, we need - to hook into the SQLCompiler to render a no-op column list. With SQLAlchemy's default implementation - the request fails with a syntax error - """ - pass - - @pytest.mark.skip(render_future_feature(FutureFeature.EMPTY_INSERT, True)) - def test_empty_insert_multiple(self): - """Empty inserts are possible using DEFAULT VALUES on Databricks. To implement it, we need - to hook into the SQLCompiler to render a no-op column list. With SQLAlchemy's default implementation - the request fails with a syntax error - """ - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.ARRAY)) -class ArrayTest(ArrayTest): - """While Databricks supports ARRAY types, DBR cannot handle bound parameters of this type. - This makes them unusable to SQLAlchemy without some workaround. Potentially we could inline - the values of these parameters (which risks sql injection). - """ - - -@pytest.mark.reviewed -@pytest.mark.skip(render_future_feature(FutureFeature.TEST_DESIGN, True)) -class QuotedNameArgumentTest(QuotedNameArgumentTest): - """These tests are challenging. The whole test setup depends on a table with a name like `quote ' one` - which will never work on Databricks because table names can't contains spaces. But QuotedNamedArgumentTest - also checks the behaviour of DDL identifier preparation process. We need to override some of IdentifierPreparer - methods because these are the ultimate control for whether or not CHECK and UNIQUE constraints are emitted. - """ - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_future_feature(FutureFeature.GENERATED_COLUMNS)) -class ComputedColumnTest(ComputedColumnTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_future_feature(FutureFeature.GENERATED_COLUMNS)) -class ComputedReflectionTest(ComputedReflectionTest): - pass diff --git a/src/databricks/sqlalchemy/test/_regression.py b/src/databricks/sqlalchemy/test/_regression.py deleted file mode 100644 index 4dbc5ec..0000000 --- a/src/databricks/sqlalchemy/test/_regression.py +++ /dev/null @@ -1,311 +0,0 @@ -# type: ignore - -import pytest -from sqlalchemy.testing.suite import ( - ArgSignatureTest, - BooleanTest, - CastTypeDecoratorTest, - ComponentReflectionTestExtra, - CompositeKeyReflectionTest, - CompoundSelectTest, - DateHistoricTest, - DateTest, - DateTimeCoercedToDateTimeTest, - DateTimeHistoricTest, - DateTimeMicrosecondsTest, - DateTimeTest, - DeprecatedCompoundSelectTest, - DistinctOnTest, - EscapingTest, - ExistsTest, - ExpandingBoundInTest, - FetchLimitOffsetTest, - FutureTableDDLTest, - HasTableTest, - IdentityAutoincrementTest, - InsertBehaviorTest, - IntegerTest, - IsOrIsNotDistinctFromTest, - JoinTest, - LikeFunctionsTest, - NormalizedNameTest, - NumericTest, - OrderByLabelTest, - PingTest, - PostCompileParamsTest, - ReturningGuardsTest, - RowFetchTest, - SameNamedSchemaTableTest, - StringTest, - TableDDLTest, - TableNoColumnsTest, - TextTest, - TimeMicrosecondsTest, - TimestampMicrosecondsTest, - TimeTest, - TimeTZTest, - TrueDivTest, - UnicodeTextTest, - UnicodeVarcharTest, - UuidTest, - ValuesExpressionTest, -) - -from databricks.sqlalchemy.test.overrides._ctetest import CTETest -from databricks.sqlalchemy.test.overrides._componentreflectiontest import ( - ComponentReflectionTest, -) - - -@pytest.mark.reviewed -class NumericTest(NumericTest): - pass - - -@pytest.mark.reviewed -class HasTableTest(HasTableTest): - pass - - -@pytest.mark.reviewed -class ComponentReflectionTestExtra(ComponentReflectionTestExtra): - pass - - -@pytest.mark.reviewed -class InsertBehaviorTest(InsertBehaviorTest): - pass - - -@pytest.mark.reviewed -class ComponentReflectionTest(ComponentReflectionTest): - """This test requires two schemas be present in the target Databricks workspace: - - The schema set in --dburi - - A second schema named "test_schema" - - Note that test_get_multi_foreign keys is flaky because DBR does not guarantee the order of data returned in DESCRIBE TABLE EXTENDED - - _Most_ of these tests pass if we manually override the bad test setup. - """ - - pass - - -@pytest.mark.reviewed -class TableDDLTest(TableDDLTest): - pass - - -@pytest.mark.reviewed -class FutureTableDDLTest(FutureTableDDLTest): - pass - - -@pytest.mark.reviewed -class FetchLimitOffsetTest(FetchLimitOffsetTest): - pass - - -@pytest.mark.reviewed -class UuidTest(UuidTest): - pass - - -@pytest.mark.reviewed -class ValuesExpressionTest(ValuesExpressionTest): - pass - - -@pytest.mark.reviewed -class BooleanTest(BooleanTest): - pass - - -@pytest.mark.reviewed -class PostCompileParamsTest(PostCompileParamsTest): - pass - - -@pytest.mark.reviewed -class TimeMicrosecondsTest(TimeMicrosecondsTest): - pass - - -@pytest.mark.reviewed -class TextTest(TextTest): - pass - - -@pytest.mark.reviewed -class StringTest(StringTest): - pass - - -@pytest.mark.reviewed -class DateTimeMicrosecondsTest(DateTimeMicrosecondsTest): - pass - - -@pytest.mark.reviewed -class TimestampMicrosecondsTest(TimestampMicrosecondsTest): - pass - - -@pytest.mark.reviewed -class DateTimeCoercedToDateTimeTest(DateTimeCoercedToDateTimeTest): - pass - - -@pytest.mark.reviewed -class TimeTest(TimeTest): - pass - - -@pytest.mark.reviewed -class DateTimeTest(DateTimeTest): - pass - - -@pytest.mark.reviewed -class DateTimeHistoricTest(DateTimeHistoricTest): - pass - - -@pytest.mark.reviewed -class DateTest(DateTest): - pass - - -@pytest.mark.reviewed -class DateHistoricTest(DateHistoricTest): - pass - - -@pytest.mark.reviewed -class RowFetchTest(RowFetchTest): - pass - - -@pytest.mark.reviewed -class CompositeKeyReflectionTest(CompositeKeyReflectionTest): - pass - - -@pytest.mark.reviewed -class TrueDivTest(TrueDivTest): - pass - - -@pytest.mark.reviewed -class ArgSignatureTest(ArgSignatureTest): - pass - - -@pytest.mark.reviewed -class CompoundSelectTest(CompoundSelectTest): - pass - - -@pytest.mark.reviewed -class DeprecatedCompoundSelectTest(DeprecatedCompoundSelectTest): - pass - - -@pytest.mark.reviewed -class CastTypeDecoratorTest(CastTypeDecoratorTest): - pass - - -@pytest.mark.reviewed -class DistinctOnTest(DistinctOnTest): - pass - - -@pytest.mark.reviewed -class EscapingTest(EscapingTest): - pass - - -@pytest.mark.reviewed -class ExistsTest(ExistsTest): - pass - - -@pytest.mark.reviewed -class IntegerTest(IntegerTest): - pass - - -@pytest.mark.reviewed -class IsOrIsNotDistinctFromTest(IsOrIsNotDistinctFromTest): - pass - - -@pytest.mark.reviewed -class JoinTest(JoinTest): - pass - - -@pytest.mark.reviewed -class OrderByLabelTest(OrderByLabelTest): - pass - - -@pytest.mark.reviewed -class PingTest(PingTest): - pass - - -@pytest.mark.reviewed -class ReturningGuardsTest(ReturningGuardsTest): - pass - - -@pytest.mark.reviewed -class SameNamedSchemaTableTest(SameNamedSchemaTableTest): - pass - - -@pytest.mark.reviewed -class UnicodeTextTest(UnicodeTextTest): - pass - - -@pytest.mark.reviewed -class UnicodeVarcharTest(UnicodeVarcharTest): - pass - - -@pytest.mark.reviewed -class TableNoColumnsTest(TableNoColumnsTest): - pass - - -@pytest.mark.reviewed -class ExpandingBoundInTest(ExpandingBoundInTest): - pass - - -@pytest.mark.reviewed -class CTETest(CTETest): - pass - - -@pytest.mark.reviewed -class NormalizedNameTest(NormalizedNameTest): - pass - - -@pytest.mark.reviewed -class IdentityAutoincrementTest(IdentityAutoincrementTest): - pass - - -@pytest.mark.reviewed -class LikeFunctionsTest(LikeFunctionsTest): - pass - - -@pytest.mark.reviewed -class TimeTZTest(TimeTZTest): - pass diff --git a/src/databricks/sqlalchemy/test/_unsupported.py b/src/databricks/sqlalchemy/test/_unsupported.py deleted file mode 100644 index c1f8120..0000000 --- a/src/databricks/sqlalchemy/test/_unsupported.py +++ /dev/null @@ -1,450 +0,0 @@ -# type: ignore - -from enum import Enum - -import pytest -from databricks.sqlalchemy.test._regression import ( - ComponentReflectionTest, - ComponentReflectionTestExtra, - CTETest, - FetchLimitOffsetTest, - FutureTableDDLTest, - HasTableTest, - InsertBehaviorTest, - NumericTest, - TableDDLTest, - UuidTest, -) - -# These are test suites that are fully skipped with a SkipReason -from sqlalchemy.testing.suite import ( - AutocommitIsolationTest, - DateTimeTZTest, - ExceptionTest, - HasIndexTest, - HasSequenceTest, - HasSequenceTestEmpty, - IsolationLevelTest, - LastrowidTest, - LongNameBlowoutTest, - PercentSchemaNamesTest, - ReturningTest, - SequenceCompilerTest, - SequenceTest, - ServerSideCursorsTest, - UnicodeSchemaTest, -) - - -class SkipReason(Enum): - AUTO_INC = "implicit AUTO_INCREMENT" - CTE_FEAT = "required CTE features" - CURSORS = "server-side cursors" - DECIMAL_FEAT = "required decimal features" - ENFORCE_KEYS = "enforcing primary or foreign key restraints" - FETCH = "fetch clauses" - IDENTIFIER_LENGTH = "identifiers > 255 characters" - IMPL_FLOAT_PREC = "required implicit float precision" - IMPLICIT_ORDER = "deterministic return order if ORDER BY is not present" - INDEXES = "SQL INDEXes" - RETURNING = "INSERT ... RETURNING syntax" - SEQUENCES = "SQL SEQUENCES" - STRING_FEAT = "required STRING type features" - SYMBOL_CHARSET = "symbols expected by test" - TEMP_TBL = "temporary tables" - TIMEZONE_OPT = "timezone-optional TIMESTAMP fields" - TRANSACTIONS = "transactions" - UNIQUE = "UNIQUE constraints" - - -def render_skip_reason(rsn: SkipReason, setup_error=False, extra=False) -> str: - prefix = "[BADSETUP]" if setup_error else "" - postfix = " More detail in _unsupported.py" if extra else "" - return f"[UNSUPPORTED]{prefix}[{rsn.name}]: Databricks does not support {rsn.value}.{postfix}" - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.ENFORCE_KEYS)) -class ExceptionTest(ExceptionTest): - """Per Databricks documentation, primary and foreign key constraints are informational only - and are not enforced. - - https://docs.databricks.com/api/workspace/tableconstraints - """ - - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.IDENTIFIER_LENGTH)) -class LongNameBlowoutTest(LongNameBlowoutTest): - """These tests all include assertions that the tested name > 255 characters""" - - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.SEQUENCES)) -class HasSequenceTest(HasSequenceTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.SEQUENCES)) -class HasSequenceTestEmpty(HasSequenceTestEmpty): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.INDEXES)) -class HasIndexTest(HasIndexTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.SYMBOL_CHARSET)) -class UnicodeSchemaTest(UnicodeSchemaTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.CURSORS)) -class ServerSideCursorsTest(ServerSideCursorsTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.SYMBOL_CHARSET)) -class PercentSchemaNamesTest(PercentSchemaNamesTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.TRANSACTIONS)) -class IsolationLevelTest(IsolationLevelTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.TRANSACTIONS)) -class AutocommitIsolationTest(AutocommitIsolationTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.RETURNING)) -class ReturningTest(ReturningTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.SEQUENCES)) -class SequenceTest(SequenceTest): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(reason=render_skip_reason(SkipReason.SEQUENCES)) -class SequenceCompilerTest(SequenceCompilerTest): - pass - - -class FetchLimitOffsetTest(FetchLimitOffsetTest): - @pytest.mark.flaky - @pytest.mark.skip(reason=render_skip_reason(SkipReason.IMPLICIT_ORDER, extra=True)) - def test_limit_render_multiple_times(self): - """This test depends on the order that records are inserted into the table. It's passing criteria requires that - a record inserted with id=1 is the first record returned when no ORDER BY clause is specified. But Databricks occasionally - INSERTS in a different order, which makes this test seem to fail. The test is flaky, but the underlying functionality - (can multiple LIMIT clauses be rendered) is not broken. - - Unclear if this is a bug in Databricks, Delta, or some race-condition in the test itself. - """ - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_bound_fetch_offset(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_fetch_offset_no_order(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_fetch_offset_nobinds(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_simple_fetch(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_simple_fetch_offset(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_simple_fetch_percent(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_simple_fetch_percent_ties(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_simple_fetch_ties(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_expr_fetch_offset(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_fetch_offset_percent(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_fetch_offset_percent_ties(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_fetch_offset_ties(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.FETCH)) - def test_fetch_offset_ties_exact_number(self): - pass - - -class UuidTest(UuidTest): - @pytest.mark.skip(reason=render_skip_reason(SkipReason.RETURNING)) - def test_uuid_returning(self): - pass - - -class FutureTableDDLTest(FutureTableDDLTest): - @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES)) - def test_create_index_if_not_exists(self): - """We could use requirements.index_reflection and requirements.index_ddl_if_exists - here to disable this but prefer a more meaningful skip message - """ - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES)) - def test_drop_index_if_exists(self): - """We could use requirements.index_reflection and requirements.index_ddl_if_exists - here to disable this but prefer a more meaningful skip message - """ - pass - - -class TableDDLTest(TableDDLTest): - @pytest.mark.skip(reason=render_skip_reason(SkipReason.INDEXES)) - def test_create_index_if_not_exists(self, connection): - """We could use requirements.index_reflection and requirements.index_ddl_if_exists - here to disable this but prefer a more meaningful skip message - """ - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.INDEXES)) - def test_drop_index_if_exists(self, connection): - """We could use requirements.index_reflection and requirements.index_ddl_if_exists - here to disable this but prefer a more meaningful skip message - """ - pass - - -class ComponentReflectionTest(ComponentReflectionTest): - """This test requires two schemas be present in the target Databricks workspace: - - The schema set in --dburi - - A second schema named "test_schema" - - Note that test_get_multi_foreign keys is flaky because DBR does not guarantee the order of data returned in DESCRIBE TABLE EXTENDED - """ - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.UNIQUE)) - def test_get_multi_unique_constraints(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL, True, True)) - def test_get_temp_view_names(self): - """While Databricks supports temporary views, this test creates a temp view aimed at a temp table. - Databricks doesn't support temp tables. So the test can never pass. - """ - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL)) - def test_get_temp_table_columns(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL)) - def test_get_temp_table_indexes(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL)) - def test_get_temp_table_names(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL)) - def test_get_temp_table_unique_constraints(self): - pass - - @pytest.mark.skip(reason=render_skip_reason(SkipReason.TEMP_TBL)) - def test_reflect_table_temp_table(self): - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES)) - def test_get_indexes(self): - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES)) - def test_multi_indexes(self): - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES)) - def get_noncol_index(self): - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.UNIQUE)) - def test_get_unique_constraints(self): - pass - - -class NumericTest(NumericTest): - @pytest.mark.skip(render_skip_reason(SkipReason.DECIMAL_FEAT)) - def test_enotation_decimal(self): - """This test automatically runs if requirements.precision_numerics_enotation_large is open()""" - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.DECIMAL_FEAT)) - def test_enotation_decimal_large(self): - """This test automatically runs if requirements.precision_numerics_enotation_large is open()""" - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.IMPL_FLOAT_PREC, extra=True)) - def test_float_coerce_round_trip(self): - """ - This automatically runs if requirements.literal_float_coercion is open() - - Without additional work, Databricks returns 15.75629997253418 when you SELECT 15.7563. - This is a potential area where we could override the Float literal processor to add a CAST. - Will leave to a PM to decide if we should do so. - """ - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.IMPL_FLOAT_PREC, extra=True)) - def test_float_custom_scale(self): - """This test automatically runs if requirements.precision_generic_float_type is open()""" - pass - - -class HasTableTest(HasTableTest): - """Databricks does not support temporary tables.""" - - @pytest.mark.skip(render_skip_reason(SkipReason.TEMP_TBL)) - def test_has_table_temp_table(self): - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.TEMP_TBL, True, True)) - def test_has_table_temp_view(self): - """Databricks supports temporary views but this test depends on requirements.has_temp_table, which we - explicitly close so that we can run other tests in this group. See the comment under has_temp_table in - requirements.py for details. - - From what I can see, there is no way to run this test since it will fail during setup if we mark has_temp_table - open(). It _might_ be possible to hijack this behaviour by implementing temp_table_keyword_args in our own - provision.py. Doing so would mean creating a real table during this class setup instead of a temp table. Then - we could just skip the temp table tests but run the temp view tests. But this test fixture doesn't cleanup its - temp tables and has no hook to do so. - - It would be ideal for SQLAlchemy to define a separate requirements.has_temp_views. - """ - pass - - -class ComponentReflectionTestExtra(ComponentReflectionTestExtra): - @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES)) - def test_reflect_covering_index(self): - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.INDEXES)) - def test_reflect_expression_based_indexes(self): - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.STRING_FEAT, extra=True)) - def test_varchar_reflection(self): - """Databricks doesn't enforce string length limitations like STRING(255).""" - pass - - -class InsertBehaviorTest(InsertBehaviorTest): - @pytest.mark.skip(render_skip_reason(SkipReason.AUTO_INC, True, True)) - def test_autoclose_on_insert(self): - """The setup for this test creates a column with implicit autoincrement enabled. - This dialect does not implement implicit autoincrement - users must declare Identity() explicitly. - """ - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.AUTO_INC, True, True)) - def test_insert_from_select_autoinc(self): - """Implicit autoincrement is not implemented in this dialect.""" - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.AUTO_INC, True, True)) - def test_insert_from_select_autoinc_no_rows(self): - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.RETURNING)) - def test_autoclose_on_insert_implicit_returning(self): - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(render_skip_reason(SkipReason.AUTO_INC, extra=True)) -class LastrowidTest(LastrowidTest): - """SQLAlchemy docs describe that a column without an explicit Identity() may implicitly create one if autoincrement=True. - That is what this method tests. Databricks supports auto-incrementing IDENTITY columns but they must be explicitly - declared. This limitation is present in our dialect as well. Which means that SQLAlchemy's autoincrement setting of a column - is ignored. We emit a logging.WARN message if you try it. - - In the future we could handle this autoincrement by implicitly calling the visit_identity_column() method of our DDLCompiler - when autoincrement=True. There is an example of this in the Microsoft SQL Server dialect: MSSDDLCompiler.get_column_specification - - For now, if you need to create a SQLAlchemy column with an auto-incrementing identity, you must set this explicitly in your column - definition by passing an Identity() to the column constructor. - """ - - pass - - -class CTETest(CTETest): - """During the teardown for this test block, it tries to drop a constraint that it never named which raises - a compilation error. This could point to poor constraint reflection but our other constraint reflection - tests pass. Requires investigation. - """ - - @pytest.mark.skip(render_skip_reason(SkipReason.CTE_FEAT, extra=True)) - def test_select_recursive_round_trip(self): - pass - - @pytest.mark.skip(render_skip_reason(SkipReason.CTE_FEAT, extra=True)) - def test_delete_scalar_subq_round_trip(self): - """Error received is [UNSUPPORTED_SUBQUERY_EXPRESSION_CATEGORY.MUST_AGGREGATE_CORRELATED_SCALAR_SUBQUERY] - - This suggests a limitation of the platform. But a workaround may be possible if customers require it. - """ - pass - - -@pytest.mark.reviewed -@pytest.mark.skip(render_skip_reason(SkipReason.TIMEZONE_OPT, True)) -class DateTimeTZTest(DateTimeTZTest): - """Test whether the sqlalchemy.DateTime() type can _optionally_ include timezone info. - This dialect maps DateTime() → TIMESTAMP, which _always_ includes tzinfo. - - Users can use databricks.sqlalchemy.TIMESTAMP_NTZ for a tzinfo-less timestamp. The SQLA docs - acknowledge this is expected for some dialects. - - https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.DateTime - """ - - pass diff --git a/src/databricks/sqlalchemy/test/conftest.py b/src/databricks/sqlalchemy/test/conftest.py deleted file mode 100644 index ea43e8d..0000000 --- a/src/databricks/sqlalchemy/test/conftest.py +++ /dev/null @@ -1,13 +0,0 @@ -from sqlalchemy.dialects import registry -import pytest - -registry.register("databricks", "databricks.sqlalchemy", "DatabricksDialect") -# sqlalchemy's dialect-testing machinery wants an entry like this. -# This seems to be based around dialects maybe having multiple drivers -# and wanting to test driver-specific URLs, but doesn't seem to make -# much sense for dialects with only one driver. -registry.register("databricks.databricks", "databricks.sqlalchemy", "DatabricksDialect") - -pytest.register_assert_rewrite("sqlalchemy.testing.assertions") - -from sqlalchemy.testing.plugin.pytestplugin import * diff --git a/src/databricks/sqlalchemy/test/overrides/_componentreflectiontest.py b/src/databricks/sqlalchemy/test/overrides/_componentreflectiontest.py deleted file mode 100644 index a1f58fa..0000000 --- a/src/databricks/sqlalchemy/test/overrides/_componentreflectiontest.py +++ /dev/null @@ -1,189 +0,0 @@ -"""The default test setup uses self-referential foreign keys and indexes for a test table. -We override to remove these assumptions. - -Note that test_multi_foreign_keys currently does not pass for all combinations due to -an ordering issue. The dialect returns the expected information. But this test makes assertions -on the order of the returned results. We can't guarantee that order at the moment. - -The test fixture actually tries to sort the outputs, but this sort isn't working. Will need -to follow-up on this later. -""" -import sqlalchemy as sa -from sqlalchemy.testing import config -from sqlalchemy.testing.schema import Column -from sqlalchemy.testing.schema import Table -from sqlalchemy import ForeignKey -from sqlalchemy import testing - -from sqlalchemy.testing.suite.test_reflection import ComponentReflectionTest - - -class ComponentReflectionTest(ComponentReflectionTest): # type: ignore - @classmethod - def define_reflected_tables(cls, metadata, schema): - if schema: - schema_prefix = schema + "." - else: - schema_prefix = "" - - if testing.requires.self_referential_foreign_keys.enabled: - parent_id_args = ( - ForeignKey( - "%susers.user_id" % schema_prefix, name="user_id_fk", use_alter=True - ), - ) - else: - parent_id_args = () - users = Table( - "users", - metadata, - Column("user_id", sa.INT, primary_key=True), - Column("test1", sa.CHAR(5), nullable=False), - Column("test2", sa.Float(), nullable=False), - Column("parent_user_id", sa.Integer, *parent_id_args), - sa.CheckConstraint( - "test2 > 0", - name="zz_test2_gt_zero", - comment="users check constraint", - ), - sa.CheckConstraint("test2 <= 1000"), - schema=schema, - test_needs_fk=True, - ) - - Table( - "dingalings", - metadata, - Column("dingaling_id", sa.Integer, primary_key=True), - Column( - "address_id", - sa.Integer, - ForeignKey( - "%semail_addresses.address_id" % schema_prefix, - name="zz_email_add_id_fg", - comment="di fk comment", - ), - ), - Column( - "id_user", - sa.Integer, - ForeignKey("%susers.user_id" % schema_prefix), - ), - Column("data", sa.String(30), unique=True), - sa.CheckConstraint( - "address_id > 0 AND address_id < 1000", - name="address_id_gt_zero", - ), - sa.UniqueConstraint( - "address_id", - "dingaling_id", - name="zz_dingalings_multiple", - comment="di unique comment", - ), - schema=schema, - test_needs_fk=True, - ) - Table( - "email_addresses", - metadata, - Column("address_id", sa.Integer), - Column("remote_user_id", sa.Integer, ForeignKey(users.c.user_id)), - Column("email_address", sa.String(20)), - sa.PrimaryKeyConstraint( - "address_id", name="email_ad_pk", comment="ea pk comment" - ), - schema=schema, - test_needs_fk=True, - ) - Table( - "comment_test", - metadata, - Column("id", sa.Integer, primary_key=True, comment="id comment"), - Column("data", sa.String(20), comment="data % comment"), - Column( - "d2", - sa.String(20), - comment=r"""Comment types type speedily ' " \ '' Fun!""", - ), - Column("d3", sa.String(42), comment="Comment\nwith\rescapes"), - schema=schema, - comment=r"""the test % ' " \ table comment""", - ) - Table( - "no_constraints", - metadata, - Column("data", sa.String(20)), - schema=schema, - comment="no\nconstraints\rhas\fescaped\vcomment", - ) - - if testing.requires.cross_schema_fk_reflection.enabled: - if schema is None: - Table( - "local_table", - metadata, - Column("id", sa.Integer, primary_key=True), - Column("data", sa.String(20)), - Column( - "remote_id", - ForeignKey("%s.remote_table_2.id" % testing.config.test_schema), - ), - test_needs_fk=True, - schema=config.db.dialect.default_schema_name, - ) - else: - Table( - "remote_table", - metadata, - Column("id", sa.Integer, primary_key=True), - Column( - "local_id", - ForeignKey( - "%s.local_table.id" % config.db.dialect.default_schema_name - ), - ), - Column("data", sa.String(20)), - schema=schema, - test_needs_fk=True, - ) - Table( - "remote_table_2", - metadata, - Column("id", sa.Integer, primary_key=True), - Column("data", sa.String(20)), - schema=schema, - test_needs_fk=True, - ) - - if testing.requires.index_reflection.enabled: - Index("users_t_idx", users.c.test1, users.c.test2, unique=True) - Index("users_all_idx", users.c.user_id, users.c.test2, users.c.test1) - - if not schema: - # test_needs_fk is at the moment to force MySQL InnoDB - noncol_idx_test_nopk = Table( - "noncol_idx_test_nopk", - metadata, - Column("q", sa.String(5)), - test_needs_fk=True, - ) - - noncol_idx_test_pk = Table( - "noncol_idx_test_pk", - metadata, - Column("id", sa.Integer, primary_key=True), - Column("q", sa.String(5)), - test_needs_fk=True, - ) - - if ( - testing.requires.indexes_with_ascdesc.enabled - and testing.requires.reflect_indexes_with_ascdesc.enabled - ): - Index("noncol_idx_nopk", noncol_idx_test_nopk.c.q.desc()) - Index("noncol_idx_pk", noncol_idx_test_pk.c.q.desc()) - - if testing.requires.view_column_reflection.enabled: - cls.define_views(metadata, schema) - if not schema and testing.requires.temp_table_reflection.enabled: - cls.define_temp_tables(metadata) diff --git a/src/databricks/sqlalchemy/test/overrides/_ctetest.py b/src/databricks/sqlalchemy/test/overrides/_ctetest.py deleted file mode 100644 index 3cdae03..0000000 --- a/src/databricks/sqlalchemy/test/overrides/_ctetest.py +++ /dev/null @@ -1,33 +0,0 @@ -"""The default test setup uses a self-referential foreign key. With our dialect this requires -`use_alter=True` and the fk constraint to be named. So we override this to make the test pass. -""" - -from sqlalchemy.testing.suite import CTETest - -from sqlalchemy.testing.schema import Column -from sqlalchemy.testing.schema import Table -from sqlalchemy import ForeignKey -from sqlalchemy import Integer -from sqlalchemy import String - - -class CTETest(CTETest): # type: ignore - @classmethod - def define_tables(cls, metadata): - Table( - "some_table", - metadata, - Column("id", Integer, primary_key=True), - Column("data", String(50)), - Column( - "parent_id", ForeignKey("some_table.id", name="fk_test", use_alter=True) - ), - ) - - Table( - "some_other_table", - metadata, - Column("id", Integer, primary_key=True), - Column("data", String(50)), - Column("parent_id", Integer), - ) diff --git a/src/databricks/sqlalchemy/test/test_suite.py b/src/databricks/sqlalchemy/test/test_suite.py deleted file mode 100644 index 2b40a43..0000000 --- a/src/databricks/sqlalchemy/test/test_suite.py +++ /dev/null @@ -1,13 +0,0 @@ -""" -The order of these imports is important. Test cases are imported first from SQLAlchemy, -then are overridden by our local skip markers in _regression, _unsupported, and _future. -""" - - -# type: ignore -# fmt: off -from sqlalchemy.testing.suite import * -from databricks.sqlalchemy.test._regression import * -from databricks.sqlalchemy.test._unsupported import * -from databricks.sqlalchemy.test._future import * -from databricks.sqlalchemy.test._extra import TinyIntegerTest, DateTimeTZTestCustom diff --git a/src/databricks/sqlalchemy/test_local/__init__.py b/src/databricks/sqlalchemy/test_local/__init__.py deleted file mode 100644 index eca1cf5..0000000 --- a/src/databricks/sqlalchemy/test_local/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -""" -This module contains tests entirely maintained by Databricks. - -These tests do not rely on SQLAlchemy's custom test runner. -""" diff --git a/src/databricks/sqlalchemy/test_local/conftest.py b/src/databricks/sqlalchemy/test_local/conftest.py deleted file mode 100644 index c8b350b..0000000 --- a/src/databricks/sqlalchemy/test_local/conftest.py +++ /dev/null @@ -1,44 +0,0 @@ -import os -import pytest - - -@pytest.fixture(scope="session") -def host(): - return os.getenv("DATABRICKS_SERVER_HOSTNAME") - - -@pytest.fixture(scope="session") -def http_path(): - return os.getenv("DATABRICKS_HTTP_PATH") - - -@pytest.fixture(scope="session") -def access_token(): - return os.getenv("DATABRICKS_TOKEN") - - -@pytest.fixture(scope="session") -def ingestion_user(): - return os.getenv("DATABRICKS_USER") - - -@pytest.fixture(scope="session") -def catalog(): - return os.getenv("DATABRICKS_CATALOG") - - -@pytest.fixture(scope="session") -def schema(): - return os.getenv("DATABRICKS_SCHEMA", "default") - - -@pytest.fixture(scope="session", autouse=True) -def connection_details(host, http_path, access_token, ingestion_user, catalog, schema): - return { - "host": host, - "http_path": http_path, - "access_token": access_token, - "ingestion_user": ingestion_user, - "catalog": catalog, - "schema": schema, - } diff --git a/src/databricks/sqlalchemy/test_local/e2e/MOCK_DATA.xlsx b/src/databricks/sqlalchemy/test_local/e2e/MOCK_DATA.xlsx deleted file mode 100644 index e080689a9d978891664c1848474f64401a453165..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 59837 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 Ki0m!^!2bbc3S|iZ diff --git a/src/databricks/sqlalchemy/test_local/e2e/test_basic.py b/src/databricks/sqlalchemy/test_local/e2e/test_basic.py deleted file mode 100644 index ce0b5d8..0000000 --- a/src/databricks/sqlalchemy/test_local/e2e/test_basic.py +++ /dev/null @@ -1,543 +0,0 @@ -import datetime -import decimal -from typing import Tuple, Union, List -from unittest import skipIf - -import pytest -from sqlalchemy import ( - Column, - MetaData, - Table, - Text, - create_engine, - insert, - select, - text, -) -from sqlalchemy.engine import Engine -from sqlalchemy.engine.reflection import Inspector -from sqlalchemy.orm import DeclarativeBase, Mapped, Session, mapped_column -from sqlalchemy.schema import DropColumnComment, SetColumnComment -from sqlalchemy.types import BOOLEAN, DECIMAL, Date, Integer, String - -try: - from sqlalchemy.orm import declarative_base -except ImportError: - from sqlalchemy.ext.declarative import declarative_base - - -USER_AGENT_TOKEN = "PySQL e2e Tests" - - -def sqlalchemy_1_3(): - import sqlalchemy - - return sqlalchemy.__version__.startswith("1.3") - - -def version_agnostic_select(object_to_select, *args, **kwargs): - """ - SQLAlchemy==1.3.x requires arguments to select() to be a Python list - - https://docs.sqlalchemy.org/en/20/changelog/migration_14.html#orm-query-is-internally-unified-with-select-update-delete-2-0-style-execution-available - """ - - if sqlalchemy_1_3(): - return select([object_to_select], *args, **kwargs) - else: - return select(object_to_select, *args, **kwargs) - - -def version_agnostic_connect_arguments(connection_details) -> Tuple[str, dict]: - HOST = connection_details["host"] - HTTP_PATH = connection_details["http_path"] - ACCESS_TOKEN = connection_details["access_token"] - CATALOG = connection_details["catalog"] - SCHEMA = connection_details["schema"] - - ua_connect_args = {"_user_agent_entry": USER_AGENT_TOKEN} - - if sqlalchemy_1_3(): - conn_string = f"databricks://token:{ACCESS_TOKEN}@{HOST}" - connect_args = { - **ua_connect_args, - "http_path": HTTP_PATH, - "server_hostname": HOST, - "catalog": CATALOG, - "schema": SCHEMA, - } - - return conn_string, connect_args - else: - return ( - f"databricks://token:{ACCESS_TOKEN}@{HOST}?http_path={HTTP_PATH}&catalog={CATALOG}&schema={SCHEMA}", - ua_connect_args, - ) - - -@pytest.fixture -def db_engine(connection_details) -> Engine: - conn_string, connect_args = version_agnostic_connect_arguments(connection_details) - return create_engine(conn_string, connect_args=connect_args) - - -def run_query(db_engine: Engine, query: Union[str, Text]): - if not isinstance(query, Text): - _query = text(query) # type: ignore - else: - _query = query # type: ignore - with db_engine.begin() as conn: - return conn.execute(_query).fetchall() - - -@pytest.fixture -def samples_engine(connection_details) -> Engine: - details = connection_details.copy() - details["catalog"] = "samples" - details["schema"] = "nyctaxi" - conn_string, connect_args = version_agnostic_connect_arguments(details) - return create_engine(conn_string, connect_args=connect_args) - - -@pytest.fixture() -def base(db_engine): - return declarative_base() - - -@pytest.fixture() -def session(db_engine): - return Session(db_engine) - - -@pytest.fixture() -def metadata_obj(db_engine): - return MetaData() - - -def test_can_connect(db_engine): - simple_query = "SELECT 1" - result = run_query(db_engine, simple_query) - assert len(result) == 1 - - -def test_connect_args(db_engine): - """Verify that extra connect args passed to sqlalchemy.create_engine are passed to DBAPI - - This will most commonly happen when partners supply a user agent entry - """ - - conn = db_engine.connect() - connection_headers = conn.connection.thrift_backend._transport._headers - user_agent = connection_headers["User-Agent"] - - expected = f"(sqlalchemy + {USER_AGENT_TOKEN})" - assert expected in user_agent - - -@pytest.mark.skipif(sqlalchemy_1_3(), reason="Pandas requires SQLAlchemy >= 1.4") -@pytest.mark.skip( - reason="DBR is currently limited to 256 parameters per call to .execute(). Test cannot pass." -) -def test_pandas_upload(db_engine, metadata_obj): - import pandas as pd - - SCHEMA = "default" - try: - df = pd.read_excel( - "src/databricks/sqlalchemy/test_local/e2e/demo_data/MOCK_DATA.xlsx" - ) - df.to_sql( - "mock_data", - db_engine, - schema=SCHEMA, - index=False, - method="multi", - if_exists="replace", - ) - - df_after = pd.read_sql_table("mock_data", db_engine, schema=SCHEMA) - assert len(df) == len(df_after) - except Exception as e: - raise e - finally: - db_engine.execute("DROP TABLE mock_data") - - -def test_create_table_not_null(db_engine, metadata_obj: MetaData): - table_name = "PySQLTest_{}".format(datetime.datetime.utcnow().strftime("%s")) - - SampleTable = Table( - table_name, - metadata_obj, - Column("name", String(255)), - Column("episodes", Integer), - Column("some_bool", BOOLEAN, nullable=False), - ) - - metadata_obj.create_all(db_engine) - - columns = db_engine.dialect.get_columns( - connection=db_engine.connect(), table_name=table_name - ) - - name_column_description = columns[0] - some_bool_column_description = columns[2] - - assert name_column_description.get("nullable") is True - assert some_bool_column_description.get("nullable") is False - - metadata_obj.drop_all(db_engine) - - -def test_column_comment(db_engine, metadata_obj: MetaData): - table_name = "PySQLTest_{}".format(datetime.datetime.utcnow().strftime("%s")) - - column = Column("name", String(255), comment="some comment") - SampleTable = Table(table_name, metadata_obj, column) - - metadata_obj.create_all(db_engine) - connection = db_engine.connect() - - columns = db_engine.dialect.get_columns( - connection=connection, table_name=table_name - ) - - assert columns[0].get("comment") == "some comment" - - column.comment = "other comment" - connection.execute(SetColumnComment(column)) - - columns = db_engine.dialect.get_columns( - connection=connection, table_name=table_name - ) - - assert columns[0].get("comment") == "other comment" - - connection.execute(DropColumnComment(column)) - - columns = db_engine.dialect.get_columns( - connection=connection, table_name=table_name - ) - - assert columns[0].get("comment") == None - - metadata_obj.drop_all(db_engine) - - -def test_bulk_insert_with_core(db_engine, metadata_obj, session): - import random - - # Maximum number of parameter is 256. 256/4 == 64 - num_to_insert = 64 - - table_name = "PySQLTest_{}".format(datetime.datetime.utcnow().strftime("%s")) - - names = ["Bim", "Miki", "Sarah", "Ira"] - - SampleTable = Table( - table_name, metadata_obj, Column("name", String(255)), Column("number", Integer) - ) - - rows = [ - {"name": names[i % 3], "number": random.choice(range(64))} - for i in range(num_to_insert) - ] - - metadata_obj.create_all(db_engine) - with db_engine.begin() as conn: - conn.execute(insert(SampleTable).values(rows)) - - with db_engine.begin() as conn: - rows = conn.execute(version_agnostic_select(SampleTable)).fetchall() - - assert len(rows) == num_to_insert - - -def test_create_insert_drop_table_core(base, db_engine, metadata_obj: MetaData): - """ """ - - SampleTable = Table( - "PySQLTest_{}".format(datetime.datetime.utcnow().strftime("%s")), - metadata_obj, - Column("name", String(255)), - Column("episodes", Integer), - Column("some_bool", BOOLEAN), - Column("dollars", DECIMAL(10, 2)), - ) - - metadata_obj.create_all(db_engine) - - insert_stmt = insert(SampleTable).values( - name="Bim Adewunmi", episodes=6, some_bool=True, dollars=decimal.Decimal(125) - ) - - with db_engine.connect() as conn: - conn.execute(insert_stmt) - - select_stmt = version_agnostic_select(SampleTable) - with db_engine.begin() as conn: - resp = conn.execute(select_stmt) - - result = resp.fetchall() - - assert len(result) == 1 - - metadata_obj.drop_all(db_engine) - - -# ORM tests are made following this tutorial -# https://docs.sqlalchemy.org/en/14/orm/quickstart.html - - -@skipIf(False, "Unity catalog must be supported") -def test_create_insert_drop_table_orm(db_engine): - """ORM classes built on the declarative base class must have a primary key. - This is restricted to Unity Catalog. - """ - - class Base(DeclarativeBase): - pass - - class SampleObject(Base): - __tablename__ = "PySQLTest_{}".format(datetime.datetime.utcnow().strftime("%s")) - - name: Mapped[str] = mapped_column(String(255), primary_key=True) - episodes: Mapped[int] = mapped_column(Integer) - some_bool: Mapped[bool] = mapped_column(BOOLEAN) - - Base.metadata.create_all(db_engine) - - sample_object_1 = SampleObject(name="Bim Adewunmi", episodes=6, some_bool=True) - sample_object_2 = SampleObject(name="Miki Meek", episodes=12, some_bool=False) - - session = Session(db_engine) - session.add(sample_object_1) - session.add(sample_object_2) - session.flush() - - stmt = version_agnostic_select(SampleObject).where( - SampleObject.name.in_(["Bim Adewunmi", "Miki Meek"]) - ) - - if sqlalchemy_1_3(): - output = [i for i in session.execute(stmt)] - else: - output = [i for i in session.scalars(stmt)] - - assert len(output) == 2 - - Base.metadata.drop_all(db_engine) - - -def test_dialect_type_mappings(db_engine, metadata_obj: MetaData): - """Confirms that we get back the same time we declared in a model and inserted using Core""" - - class Base(DeclarativeBase): - pass - - SampleTable = Table( - "PySQLTest_{}".format(datetime.datetime.utcnow().strftime("%s")), - metadata_obj, - Column("string_example", String(255)), - Column("integer_example", Integer), - Column("boolean_example", BOOLEAN), - Column("decimal_example", DECIMAL(10, 2)), - Column("date_example", Date), - ) - - string_example = "" - integer_example = 100 - boolean_example = True - decimal_example = decimal.Decimal(125) - date_example = datetime.date(2013, 1, 1) - - metadata_obj.create_all(db_engine) - - insert_stmt = insert(SampleTable).values( - string_example=string_example, - integer_example=integer_example, - boolean_example=boolean_example, - decimal_example=decimal_example, - date_example=date_example, - ) - - with db_engine.connect() as conn: - conn.execute(insert_stmt) - - select_stmt = version_agnostic_select(SampleTable) - with db_engine.begin() as conn: - resp = conn.execute(select_stmt) - - result = resp.fetchall() - this_row = result[0] - - assert this_row.string_example == string_example - assert this_row.integer_example == integer_example - assert this_row.boolean_example == boolean_example - assert this_row.decimal_example == decimal_example - assert this_row.date_example == date_example - - metadata_obj.drop_all(db_engine) - - -def test_inspector_smoke_test(samples_engine: Engine): - """It does not appear that 3L namespace is supported here""" - - schema, table = "nyctaxi", "trips" - - try: - inspector = Inspector.from_engine(samples_engine) - except Exception as e: - assert False, f"Could not build inspector: {e}" - - # Expect six columns - columns = inspector.get_columns(table, schema=schema) - - # Expect zero views, but the method should return - views = inspector.get_view_names(schema=schema) - - assert ( - len(columns) == 6 - ), "Dialect did not find the expected number of columns in samples.nyctaxi.trips" - assert len(views) == 0, "Views could not be fetched" - - -@pytest.mark.skip(reason="engine.table_names has been removed in sqlalchemy verison 2") -def test_get_table_names_smoke_test(samples_engine: Engine): - with samples_engine.connect() as conn: - _names = samples_engine.table_names(schema="nyctaxi", connection=conn) # type: ignore - _names is not None, "get_table_names did not succeed" - - -def test_has_table_across_schemas( - db_engine: Engine, samples_engine: Engine, catalog: str, schema: str -): - """For this test to pass these conditions must be met: - - Table samples.nyctaxi.trips must exist - - Table samples.tpch.customer must exist - - The `catalog` and `schema` environment variables must be set and valid - """ - - with samples_engine.connect() as conn: - # 1) Check for table within schema declared at engine creation time - assert samples_engine.dialect.has_table(connection=conn, table_name="trips") - - # 2) Check for table within another schema in the same catalog - assert samples_engine.dialect.has_table( - connection=conn, table_name="customer", schema="tpch" - ) - - # 3) Check for a table within a different catalog - # Create a table in a different catalog - with db_engine.connect() as conn: - conn.execute(text("CREATE TABLE test_has_table (numbers_are_cool INT);")) - - try: - # Verify that this table is not found in the samples catalog - assert not samples_engine.dialect.has_table( - connection=conn, table_name="test_has_table" - ) - # Verify that this table is found in a separate catalog - assert samples_engine.dialect.has_table( - connection=conn, - table_name="test_has_table", - schema=schema, - catalog=catalog, - ) - finally: - conn.execute(text("DROP TABLE test_has_table;")) - - -def test_user_agent_adjustment(db_engine): - # If .connect() is called multiple times on an engine, don't keep pre-pending the user agent - # https://github.com/databricks/databricks-sql-python/issues/192 - c1 = db_engine.connect() - c2 = db_engine.connect() - - def get_conn_user_agent(conn): - return conn.connection.dbapi_connection.thrift_backend._transport._headers.get( - "User-Agent" - ) - - ua1 = get_conn_user_agent(c1) - ua2 = get_conn_user_agent(c2) - same_ua = ua1 == ua2 - - c1.close() - c2.close() - - assert same_ua, f"User agents didn't match \n {ua1} \n {ua2}" - - -@pytest.fixture -def sample_table(metadata_obj: MetaData, db_engine: Engine): - """This fixture creates a sample table and cleans it up after the test is complete.""" - from databricks.sqlalchemy._parse import GET_COLUMNS_TYPE_MAP - - table_name = "PySQLTest_{}".format(datetime.datetime.utcnow().strftime("%s")) - - args: List[Column] = [ - Column(colname, coltype) for colname, coltype in GET_COLUMNS_TYPE_MAP.items() - ] - - SampleTable = Table(table_name, metadata_obj, *args) - - metadata_obj.create_all(db_engine) - - yield table_name - - metadata_obj.drop_all(db_engine) - - -def test_get_columns(db_engine, sample_table: str): - """Created after PECO-1297 and Github Issue #295 to verify that get_columsn behaves like it should for all known SQLAlchemy types""" - - inspector = Inspector.from_engine(db_engine) - - # this raises an exception if `parse_column_info_from_tgetcolumnsresponse` fails a lookup - columns = inspector.get_columns(sample_table) - - assert True - - -class TestCommentReflection: - @pytest.fixture(scope="class") - def engine(self, connection_details: dict): - HOST = connection_details["host"] - HTTP_PATH = connection_details["http_path"] - ACCESS_TOKEN = connection_details["access_token"] - CATALOG = connection_details["catalog"] - SCHEMA = connection_details["schema"] - - connection_string = f"databricks://token:{ACCESS_TOKEN}@{HOST}?http_path={HTTP_PATH}&catalog={CATALOG}&schema={SCHEMA}" - connect_args = {"_user_agent_entry": USER_AGENT_TOKEN} - - engine = create_engine(connection_string, connect_args=connect_args) - return engine - - @pytest.fixture - def inspector(self, engine: Engine) -> Inspector: - return Inspector.from_engine(engine) - - @pytest.fixture(scope="class") - def table(self, engine): - md = MetaData() - tbl = Table( - "foo", - md, - Column("bar", String, comment="column comment"), - comment="table comment", - ) - md.create_all(bind=engine) - - yield tbl - - md.drop_all(bind=engine) - - def test_table_comment_reflection(self, inspector: Inspector, table: Table): - comment = inspector.get_table_comment(table.name) - assert comment == {"text": "table comment"} - - def test_column_comment(self, inspector: Inspector, table: Table): - result = inspector.get_columns(table.name)[0].get("comment") - assert result == "column comment" diff --git a/src/databricks/sqlalchemy/test_local/test_ddl.py b/src/databricks/sqlalchemy/test_local/test_ddl.py deleted file mode 100644 index f596dff..0000000 --- a/src/databricks/sqlalchemy/test_local/test_ddl.py +++ /dev/null @@ -1,96 +0,0 @@ -import pytest -from sqlalchemy import Column, MetaData, String, Table, create_engine -from sqlalchemy.schema import ( - CreateTable, - DropColumnComment, - DropTableComment, - SetColumnComment, - SetTableComment, -) - - -class DDLTestBase: - engine = create_engine( - "databricks://token:****@****?http_path=****&catalog=****&schema=****" - ) - - def compile(self, stmt): - return str(stmt.compile(bind=self.engine)) - - -class TestColumnCommentDDL(DDLTestBase): - @pytest.fixture - def metadata(self) -> MetaData: - """Assemble a metadata object with one table containing one column.""" - metadata = MetaData() - - column = Column("foo", String, comment="bar") - table = Table("foobar", metadata, column) - - return metadata - - @pytest.fixture - def table(self, metadata) -> Table: - return metadata.tables.get("foobar") - - @pytest.fixture - def column(self, table) -> Column: - return table.columns[0] - - def test_create_table_with_column_comment(self, table): - stmt = CreateTable(table) - output = self.compile(stmt) - - # output is a CREATE TABLE statement - assert "foo STRING COMMENT 'bar'" in output - - def test_alter_table_add_column_comment(self, column): - stmt = SetColumnComment(column) - output = self.compile(stmt) - assert output == "ALTER TABLE foobar ALTER COLUMN foo COMMENT 'bar'" - - def test_alter_table_drop_column_comment(self, column): - stmt = DropColumnComment(column) - output = self.compile(stmt) - assert output == "ALTER TABLE foobar ALTER COLUMN foo COMMENT ''" - - -class TestTableCommentDDL(DDLTestBase): - @pytest.fixture - def metadata(self) -> MetaData: - """Assemble a metadata object with one table containing one column.""" - metadata = MetaData() - - col1 = Column("foo", String) - col2 = Column("foo", String) - tbl_w_comment = Table("martin", metadata, col1, comment="foobar") - tbl_wo_comment = Table("prs", metadata, col2) - - return metadata - - @pytest.fixture - def table_with_comment(self, metadata) -> Table: - return metadata.tables.get("martin") - - @pytest.fixture - def table_without_comment(self, metadata) -> Table: - return metadata.tables.get("prs") - - def test_create_table_with_comment(self, table_with_comment): - stmt = CreateTable(table_with_comment) - output = self.compile(stmt) - assert "USING DELTA" in output - assert "COMMENT 'foobar'" in output - - def test_alter_table_add_comment(self, table_without_comment: Table): - table_without_comment.comment = "wireless mechanical keyboard" - stmt = SetTableComment(table_without_comment) - output = self.compile(stmt) - - assert output == "COMMENT ON TABLE prs IS 'wireless mechanical keyboard'" - - def test_alter_table_drop_comment(self, table_with_comment): - """The syntax for COMMENT ON is here: https://docs.databricks.com/en/sql/language-manual/sql-ref-syntax-ddl-comment.html""" - stmt = DropTableComment(table_with_comment) - output = self.compile(stmt) - assert output == "COMMENT ON TABLE martin IS NULL" diff --git a/src/databricks/sqlalchemy/test_local/test_parsing.py b/src/databricks/sqlalchemy/test_local/test_parsing.py deleted file mode 100644 index c8ab443..0000000 --- a/src/databricks/sqlalchemy/test_local/test_parsing.py +++ /dev/null @@ -1,160 +0,0 @@ -import pytest -from databricks.sqlalchemy._parse import ( - extract_identifiers_from_string, - extract_identifier_groups_from_string, - extract_three_level_identifier_from_constraint_string, - build_fk_dict, - build_pk_dict, - match_dte_rows_by_value, - get_comment_from_dte_output, - DatabricksSqlAlchemyParseException, -) - - -# These are outputs from DESCRIBE TABLE EXTENDED -@pytest.mark.parametrize( - "input, expected", - [ - ("PRIMARY KEY (`pk1`, `pk2`)", ["pk1", "pk2"]), - ("PRIMARY KEY (`a`, `b`, `c`)", ["a", "b", "c"]), - ("PRIMARY KEY (`name`, `id`, `attr`)", ["name", "id", "attr"]), - ], -) -def test_extract_identifiers(input, expected): - assert ( - extract_identifiers_from_string(input) == expected - ), "Failed to extract identifiers from string" - - -@pytest.mark.parametrize( - "input, expected", - [ - ( - "FOREIGN KEY (`pname`, `pid`, `pattr`) REFERENCES `main`.`pysql_sqlalchemy`.`tb1` (`name`, `id`, `attr`)", - [ - "(`pname`, `pid`, `pattr`)", - "(`name`, `id`, `attr`)", - ], - ) - ], -) -def test_extract_identifer_batches(input, expected): - assert ( - extract_identifier_groups_from_string(input) == expected - ), "Failed to extract identifier groups from string" - - -def test_extract_3l_namespace_from_constraint_string(): - input = "FOREIGN KEY (`parent_user_id`) REFERENCES `main`.`pysql_dialect_compliance`.`users` (`user_id`)" - expected = { - "catalog": "main", - "schema": "pysql_dialect_compliance", - "table": "users", - } - - assert ( - extract_three_level_identifier_from_constraint_string(input) == expected - ), "Failed to extract 3L namespace from constraint string" - - -def test_extract_3l_namespace_from_bad_constraint_string(): - input = "FOREIGN KEY (`parent_user_id`) REFERENCES `pysql_dialect_compliance`.`users` (`user_id`)" - - with pytest.raises(DatabricksSqlAlchemyParseException): - extract_three_level_identifier_from_constraint_string(input) - - -@pytest.mark.parametrize("tschema", [None, "some_schema"]) -def test_build_fk_dict(tschema): - fk_constraint_string = "FOREIGN KEY (`parent_user_id`) REFERENCES `main`.`some_schema`.`users` (`user_id`)" - - result = build_fk_dict("some_fk_name", fk_constraint_string, schema_name=tschema) - - assert result == { - "name": "some_fk_name", - "constrained_columns": ["parent_user_id"], - "referred_schema": tschema, - "referred_table": "users", - "referred_columns": ["user_id"], - } - - -def test_build_pk_dict(): - pk_constraint_string = "PRIMARY KEY (`id`, `name`, `email_address`)" - pk_name = "pk1" - - result = build_pk_dict(pk_name, pk_constraint_string) - - assert result == { - "constrained_columns": ["id", "name", "email_address"], - "name": "pk1", - } - - -# This is a real example of the output from DESCRIBE TABLE EXTENDED as of 15 October 2023 -RAW_SAMPLE_DTE_OUTPUT = [ - ["id", "int"], - ["name", "string"], - ["", ""], - ["# Detailed Table Information", ""], - ["Catalog", "main"], - ["Database", "pysql_sqlalchemy"], - ["Table", "exampleexampleexample"], - ["Created Time", "Sun Oct 15 21:12:54 UTC 2023"], - ["Last Access", "UNKNOWN"], - ["Created By", "Spark "], - ["Type", "MANAGED"], - ["Location", "s3://us-west-2-****-/19a85dee-****/tables/ccb7***"], - ["Provider", "delta"], - ["Comment", "some comment"], - ["Owner", "some.user@example.com"], - ["Is_managed_location", "true"], - ["Predictive Optimization", "ENABLE (inherited from CATALOG main)"], - [ - "Table Properties", - "[delta.checkpoint.writeStatsAsJson=false,delta.checkpoint.writeStatsAsStruct=true,delta.minReaderVersion=1,delta.minWriterVersion=2]", - ], - ["", ""], - ["# Constraints", ""], - ["exampleexampleexample_pk", "PRIMARY KEY (`id`)"], - [ - "exampleexampleexample_fk", - "FOREIGN KEY (`parent_user_id`) REFERENCES `main`.`pysql_dialect_compliance`.`users` (`user_id`)", - ], -] - -FMT_SAMPLE_DT_OUTPUT = [ - {"col_name": i[0], "data_type": i[1]} for i in RAW_SAMPLE_DTE_OUTPUT -] - - -@pytest.mark.parametrize( - "match, output", - [ - ( - "PRIMARY KEY", - [ - { - "col_name": "exampleexampleexample_pk", - "data_type": "PRIMARY KEY (`id`)", - } - ], - ), - ( - "FOREIGN KEY", - [ - { - "col_name": "exampleexampleexample_fk", - "data_type": "FOREIGN KEY (`parent_user_id`) REFERENCES `main`.`pysql_dialect_compliance`.`users` (`user_id`)", - } - ], - ), - ], -) -def test_filter_dict_by_value(match, output): - result = match_dte_rows_by_value(FMT_SAMPLE_DT_OUTPUT, match) - assert result == output - - -def test_get_comment_from_dte_output(): - assert get_comment_from_dte_output(FMT_SAMPLE_DT_OUTPUT) == "some comment" diff --git a/src/databricks/sqlalchemy/test_local/test_types.py b/src/databricks/sqlalchemy/test_local/test_types.py deleted file mode 100644 index b91217e..0000000 --- a/src/databricks/sqlalchemy/test_local/test_types.py +++ /dev/null @@ -1,161 +0,0 @@ -import enum - -import pytest -import sqlalchemy - -from databricks.sqlalchemy.base import DatabricksDialect -from databricks.sqlalchemy._types import TINYINT, TIMESTAMP, TIMESTAMP_NTZ - - -class DatabricksDataType(enum.Enum): - """https://docs.databricks.com/en/sql/language-manual/sql-ref-datatypes.html""" - - BIGINT = enum.auto() - BINARY = enum.auto() - BOOLEAN = enum.auto() - DATE = enum.auto() - DECIMAL = enum.auto() - DOUBLE = enum.auto() - FLOAT = enum.auto() - INT = enum.auto() - INTERVAL = enum.auto() - VOID = enum.auto() - SMALLINT = enum.auto() - STRING = enum.auto() - TIMESTAMP = enum.auto() - TIMESTAMP_NTZ = enum.auto() - TINYINT = enum.auto() - ARRAY = enum.auto() - MAP = enum.auto() - STRUCT = enum.auto() - - -# Defines the way that SQLAlchemy CamelCase types are compiled into Databricks SQL types. -# Note: I wish I could define this within the TestCamelCaseTypesCompilation class, but pytest doesn't like that. -camel_case_type_map = { - sqlalchemy.types.BigInteger: DatabricksDataType.BIGINT, - sqlalchemy.types.LargeBinary: DatabricksDataType.BINARY, - sqlalchemy.types.Boolean: DatabricksDataType.BOOLEAN, - sqlalchemy.types.Date: DatabricksDataType.DATE, - sqlalchemy.types.DateTime: DatabricksDataType.TIMESTAMP_NTZ, - sqlalchemy.types.Double: DatabricksDataType.DOUBLE, - sqlalchemy.types.Enum: DatabricksDataType.STRING, - sqlalchemy.types.Float: DatabricksDataType.FLOAT, - sqlalchemy.types.Integer: DatabricksDataType.INT, - sqlalchemy.types.Interval: DatabricksDataType.TIMESTAMP_NTZ, - sqlalchemy.types.Numeric: DatabricksDataType.DECIMAL, - sqlalchemy.types.PickleType: DatabricksDataType.BINARY, - sqlalchemy.types.SmallInteger: DatabricksDataType.SMALLINT, - sqlalchemy.types.String: DatabricksDataType.STRING, - sqlalchemy.types.Text: DatabricksDataType.STRING, - sqlalchemy.types.Time: DatabricksDataType.STRING, - sqlalchemy.types.Unicode: DatabricksDataType.STRING, - sqlalchemy.types.UnicodeText: DatabricksDataType.STRING, - sqlalchemy.types.Uuid: DatabricksDataType.STRING, -} - - -def dict_as_tuple_list(d: dict): - """Return a list of [(key, value), ...] from a dictionary.""" - return [(key, value) for key, value in d.items()] - - -class CompilationTestBase: - dialect = DatabricksDialect() - - def _assert_compiled_value( - self, type_: sqlalchemy.types.TypeEngine, expected: DatabricksDataType - ): - """Assert that when type_ is compiled for the databricks dialect, it renders the DatabricksDataType name. - - This method initialises the type_ with no arguments. - """ - compiled_result = type_().compile(dialect=self.dialect) # type: ignore - assert compiled_result == expected.name - - def _assert_compiled_value_explicit( - self, type_: sqlalchemy.types.TypeEngine, expected: str - ): - """Assert that when type_ is compiled for the databricks dialect, it renders the expected string. - - This method expects an initialised type_ so that we can test how a TypeEngine created with arguments - is compiled. - """ - compiled_result = type_.compile(dialect=self.dialect) - assert compiled_result == expected - - -class TestCamelCaseTypesCompilation(CompilationTestBase): - """Per the sqlalchemy documentation[^1] here, the camel case members of sqlalchemy.types are - are expected to work across all dialects. These tests verify that the types compile into valid - Databricks SQL type strings. For example, the sqlalchemy.types.Integer() should compile as "INT". - - Truly custom types like STRUCT (notice the uppercase) are not expected to work across all dialects. - We test these separately. - - Note that these tests have to do with type **name** compiliation. Which is separate from actually - mapping values between Python and Databricks. - - Note: SchemaType and MatchType are not tested because it's not used in table definitions - - [1]: https://docs.sqlalchemy.org/en/20/core/type_basics.html#generic-camelcase-types - """ - - @pytest.mark.parametrize("type_, expected", dict_as_tuple_list(camel_case_type_map)) - def test_bare_camel_case_types_compile(self, type_, expected): - self._assert_compiled_value(type_, expected) - - def test_numeric_renders_as_decimal_with_precision(self): - self._assert_compiled_value_explicit( - sqlalchemy.types.Numeric(10), "DECIMAL(10)" - ) - - def test_numeric_renders_as_decimal_with_precision_and_scale(self): - self._assert_compiled_value_explicit( - sqlalchemy.types.Numeric(10, 2), "DECIMAL(10, 2)" - ) - - -uppercase_type_map = { - sqlalchemy.types.ARRAY: DatabricksDataType.ARRAY, - sqlalchemy.types.BIGINT: DatabricksDataType.BIGINT, - sqlalchemy.types.BINARY: DatabricksDataType.BINARY, - sqlalchemy.types.BOOLEAN: DatabricksDataType.BOOLEAN, - sqlalchemy.types.DATE: DatabricksDataType.DATE, - sqlalchemy.types.DECIMAL: DatabricksDataType.DECIMAL, - sqlalchemy.types.DOUBLE: DatabricksDataType.DOUBLE, - sqlalchemy.types.FLOAT: DatabricksDataType.FLOAT, - sqlalchemy.types.INT: DatabricksDataType.INT, - sqlalchemy.types.SMALLINT: DatabricksDataType.SMALLINT, - sqlalchemy.types.TIMESTAMP: DatabricksDataType.TIMESTAMP, - TINYINT: DatabricksDataType.TINYINT, - TIMESTAMP: DatabricksDataType.TIMESTAMP, - TIMESTAMP_NTZ: DatabricksDataType.TIMESTAMP_NTZ, -} - - -class TestUppercaseTypesCompilation(CompilationTestBase): - """Per the sqlalchemy documentation[^1], uppercase types are considered to be specific to some - database backends. These tests verify that the types compile into valid Databricks SQL type strings. - - [1]: https://docs.sqlalchemy.org/en/20/core/type_basics.html#backend-specific-uppercase-datatypes - """ - - @pytest.mark.parametrize("type_, expected", dict_as_tuple_list(uppercase_type_map)) - def test_bare_uppercase_types_compile(self, type_, expected): - if isinstance(type_, type(sqlalchemy.types.ARRAY)): - # ARRAY cannot be initialised without passing an item definition so we test separately - # I preserve it in the uppercase_type_map for clarity - assert True - else: - self._assert_compiled_value(type_, expected) - - def test_array_string_renders_as_array_of_string(self): - """SQLAlchemy's ARRAY type requires an item definition. And their docs indicate that they've only tested - it with Postgres since that's the only first-class dialect with support for ARRAY. - - https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.ARRAY - """ - self._assert_compiled_value_explicit( - sqlalchemy.types.ARRAY(sqlalchemy.types.String), "ARRAY" - ) From 609bc431e7075ae80e01c15efe36233985ce0db7 Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Wed, 23 Oct 2024 11:00:19 +0530 Subject: [PATCH 02/11] Fixed the README.md and other md files --- CHANGELOG.md | 273 +----------------------------------------------- CONTRIBUTING.md | 43 -------- README.md | 95 +++++++---------- 3 files changed, 39 insertions(+), 372 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4fca204..2660d32 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,274 +1,5 @@ # Release History -# 3.3.0 (2024-07-18) +# 1.0.1 -- Don't retry requests that fail with HTTP code 401 (databricks/databricks-sql-python#408 by @Hodnebo) -- Remove username/password (aka "basic") auth option (databricks/databricks-sql-python#409 by @jackyhu-db) -- Refactor CloudFetch handler to fix numerous issues with it (databricks/databricks-sql-python#405 by @kravets-levko) -- Add option to disable SSL verification for CloudFetch links (databricks/databricks-sql-python#414 by @kravets-levko) - -Databricks-managed passwords reached end of life on July 10, 2024. Therefore, Basic auth support was removed from -the library. See https://docs.databricks.com/en/security/auth-authz/password-deprecation.html - -The existing option `_tls_no_verify=True` of `sql.connect(...)` will now also disable SSL cert verification -(but not the SSL itself) for CloudFetch links. This option should be used as a workaround only, when other ways -to fix SSL certificate errors didn't work. - -# 3.2.0 (2024-06-06) - -- Update proxy authentication (databricks/databricks-sql-python#354 by @amir-haroun) -- Relax `pyarrow` pin (databricks/databricks-sql-python#389 by @dhirschfeld) -- Fix error logging in OAuth manager (databricks/databricks-sql-python#269 by @susodapop) -- SQLAlchemy: enable delta.feature.allowColumnDefaults for all tables (databricks/databricks-sql-python#343 by @dhirschfeld) -- Update `thrift` dependency (databricks/databricks-sql-python#397 by @m1n0) - -# 3.1.2 (2024-04-18) - -- Remove broken cookie code (#379) -- Small typing fixes (#382, #384 thanks @wyattscarpenter) - -# 3.1.1 (2024-03-19) - -- Don't retry requests that fail with code 403 (#373) -- Assume a default retry-after for 429/503 (#371) -- Fix boolean literals (#357) - -# 3.1.0 (2024-02-16) - -- Revert retry-after behavior to be exponential backoff (#349) -- Support Databricks OAuth on Azure (#351) -- Support Databricks OAuth on GCP (#338) - -# 3.0.3 (2024-02-02) - -- Revised docstrings and examples for OAuth (#339) -- Redact the URL query parameters from the urllib3.connectionpool logs (#341) - -# 3.0.2 (2024-01-25) - -- SQLAlchemy dialect now supports table and column comments (thanks @cbornet!) -- Fix: SQLAlchemy dialect now correctly reflects TINYINT types (thanks @TimTheinAtTabs!) -- Fix: `server_hostname` URIs that included `https://` would raise an exception -- Other: pinned to `pandas<=2.1` and `urllib3>=1.26` to avoid runtime errors in dbt-databricks (#330) - -## 3.0.1 (2023-12-01) - -- Other: updated docstring comment about default parameterization approach (#287) -- Other: added tests for reading complex types and revised docstrings and type hints (#293) -- Fix: SQLAlchemy dialect raised DeprecationWarning due to `dbapi` classmethod (#294) -- Fix: SQLAlchemy dialect could not reflect TIMESTAMP_NTZ columns (#296) - -## 3.0.0 (2023-11-17) - -- Remove support for Python 3.7 -- Add support for native parameterized SQL queries. Requires DBR 14.2 and above. See docs/parameters.md for more info. -- Completely rewritten SQLAlchemy dialect - - Adds support for SQLAlchemy >= 2.0 and drops support for SQLAlchemy 1.x - - Full e2e test coverage of all supported features - - Detailed usage notes in `README.sqlalchemy.md` - - Adds support for: - - New types: `TIME`, `TIMESTAMP`, `TIMESTAMP_NTZ`, `TINYINT` - - `Numeric` type scale and precision, like `Numeric(10,2)` - - Reading and writing `PrimaryKeyConstraint` and `ForeignKeyConstraint` - - Reading and writing composite keys - - Reading and writing from views - - Writing `Identity` to tables (i.e. autoincrementing primary keys) - - `LIMIT` and `OFFSET` for paging through results - - Caching metadata calls -- Enable cloud fetch by default. To disable, set `use_cloud_fetch=False` when building `databricks.sql.client`. -- Add integration tests for Databricks UC Volumes ingestion queries -- Retries: - - Add `_retry_max_redirects` config - - Set `_enable_v3_retries=True` and warn if users override it -- Security: bump minimum pyarrow version to 14.0.1 (CVE-2023-47248) - -## 2.9.3 (2023-08-24) - -- Fix: Connections failed when urllib3~=1.0.0 is installed (#206) - -## 2.9.2 (2023-08-17) - -**Note: this release was yanked from Pypi on 13 September 2023 due to compatibility issues with environments where `urllib3<=2.0.0` were installed. The log changes are incorporated into version 2.9.3 and greater.** - -- Other: Add `examples/v3_retries_query_execute.py` (#199) -- Other: suppress log message when `_enable_v3_retries` is not `True` (#199) -- Other: make this connector backwards compatible with `urllib3>=1.0.0` (#197) - -## 2.9.1 (2023-08-11) - -**Note: this release was yanked from Pypi on 13 September 2023 due to compatibility issues with environments where `urllib3<=2.0.0` were installed.** - -- Other: Explicitly pin urllib3 to ^2.0.0 (#191) - -## 2.9.0 (2023-08-10) - -- Replace retry handling with DatabricksRetryPolicy. This is disabled by default. To enable, set `_enable_v3_retries=True` when creating `databricks.sql.client` (#182) -- Other: Fix typo in README quick start example (#186) -- Other: Add autospec to Client mocks and tidy up `make_request` (#188) - -## 2.8.0 (2023-07-21) - -- Add support for Cloud Fetch. Disabled by default. Set `use_cloud_fetch=True` when building `databricks.sql.client` to enable it (#146, #151, #154) -- SQLAlchemy has_table function now honours schema= argument and adds catalog= argument (#174) -- SQLAlchemy set non_native_boolean_check_constraint False as it's not supported by Databricks (#120) -- Fix: Revised SQLAlchemy dialect and examples for compatibility with SQLAlchemy==1.3.x (#173) -- Fix: oauth would fail if expired credentials appeared in ~/.netrc (#122) -- Fix: Python HTTP proxies were broken after switch to urllib3 (#158) -- Other: remove unused import in SQLAlchemy dialect -- Other: Relax pandas dependency constraint to allow ^2.0.0 (#164) -- Other: Connector now logs operation handle guids as hexadecimal instead of bytes (#170) -- Other: test_socket_timeout_user_defined e2e test was broken (#144) - -## 2.7.0 (2023-06-26) - -- Fix: connector raised exception when calling close() on a closed Thrift session -- Improve e2e test development ergonomics -- Redact logged thrift responses by default -- Add support for OAuth on Databricks Azure - -## 2.6.2 (2023-06-14) - -- Fix: Retry GetOperationStatus requests for http errors - -## 2.6.1 (2023-06-08) - -- Fix: http.client would raise a BadStatusLine exception in some cases - -## 2.6.0 (2023-06-07) - -- Add support for HTTP 1.1 connections (connection pools) -- Add a default socket timeout for thrift RPCs - -## 2.5.2 (2023-05-08) - -- Fix: SQLAlchemy adapter could not reflect TIMESTAMP or DATETIME columns -- Other: Relax pandas and alembic dependency specifications - -## 2.5.1 (2023-04-28) - -- Other: Relax sqlalchemy required version as it was unecessarily strict. - -## 2.5.0 (2023-04-14) - -- Add support for External Auth providers -- Fix: Python HTTP proxies were broken -- Other: All Thrift requests that timeout during connection will be automatically retried - -## 2.4.1 (2023-03-21) - -- Less strict numpy and pyarrow dependencies -- Update examples in README to use security best practices -- Update docstring for client.execute() for clarity - -## 2.4.0 (2023-02-21) - -- Improve compatibility when installed alongside other Databricks namespace Python packages -- Add SQLAlchemy dialect - -## 2.3.0 (2023-01-10) - -- Support staging ingestion commands for DBR 12+ - -## 2.2.2 (2023-01-03) - -- Support custom oauth client id and redirect port -- Fix: Add none check on \_oauth_persistence in DatabricksOAuthProvider - -## 2.2.1 (2022-11-29) - -- Add support for Python 3.11 - -## 2.2.0 (2022-11-15) - -- Bump thrift version to address https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-13949 -- Add support for lz4 compression - -## 2.1.0 (2022-09-30) - -- Introduce experimental OAuth support while Bring Your Own IDP is in Public Preview on AWS -- Add functional examples - -## 2.0.5 (2022-08-23) - -- Fix: closing a connection now closes any open cursors from that connection at the server -- Other: Add project links to pyproject.toml (helpful for visitors from PyPi) - -## 2.0.4 (2022-08-17) - -- Add support for Python 3.10 -- Add unit test matrix for supported Python versions - -Huge thanks to @dbaxa for contributing this change! - -## 2.0.3 (2022-08-05) - -- Add retry logic for `GetOperationStatus` requests that fail with an `OSError` -- Reorganised code to use Poetry for dependency management. - -## 2.0.2 (2022-05-04) - -- Better exception handling in automatic connection close - -## 2.0.1 (2022-04-21) - -- Fixed Pandas dependency in setup.cfg to be >= 1.2.0 - -## 2.0.0 (2022-04-19) - -- Initial stable release of V2 -- Added better support for complex types, so that in Databricks runtime 10.3+, Arrays, Maps and Structs will get - deserialized as lists, lists of tuples and dicts, respectively. -- Changed the name of the metadata arg to http_headers - -## 2.0.b2 (2022-04-04) - -- Change import of collections.Iterable to collections.abc.Iterable to make the library compatible with Python 3.10 -- Fixed bug with .tables method so that .tables works as expected with Unity-Catalog enabled endpoints - -## 2.0.0b1 (2022-03-04) - -- Fix packaging issue (dependencies were not being installed properly) -- Fetching timestamp results will now return aware instead of naive timestamps -- The client will now default to using simplified error messages - -## 2.0.0b (2022-02-08) - -- Initial beta release of V2. V2 is an internal re-write of large parts of the connector to use Databricks edge features. All public APIs from V1 remain. -- Added Unity Catalog support (pass catalog and / or schema key word args to the .connect method to select initial schema and catalog) - ---- - -**Note**: The code for versions prior to `v2.0.0b` is not contained in this repository. The below entries are included for reference only. - ---- - -## 1.0.0 (2022-01-20) - -- Add operations for retrieving metadata -- Add the ability to access columns by name on result rows -- Add the ability to provide configuration settings on connect - -## 0.9.4 (2022-01-10) - -- Improved logging and error messages. - -## 0.9.3 (2021-12-08) - -- Add retries for 429 and 503 HTTP responses. - -## 0.9.2 (2021-12-02) - -- (Bug fix) Increased Thrift requirement from 0.10.0 to 0.13.0 as 0.10.0 was in fact incompatible -- (Bug fix) Fixed error message after query execution failed -SQLSTATE and Error message were misplaced - -## 0.9.1 (2021-09-01) - -- Public Preview release, Experimental tag removed -- minor updates in internal build/packaging -- no functional changes - -## 0.9.0 (2021-08-04) - -- initial (Experimental) release of pyhive-forked connector -- Python DBAPI 2.0 (PEP-0249), thrift based -- see docs for more info: https://docs.databricks.com/dev-tools/python-sql-connector.html +- This is databricks-sqlalchemy plugin based on sqlalchemy v1 and has all the databricks-sql-python v2.9.6 needed sqlalchemy features diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 3836030..74cf5f7 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -76,49 +76,6 @@ This project uses [Poetry](https://python-poetry.org/) for dependency management 1. Clone this respository 2. Run `poetry install` -### Run tests - -We use [Pytest](https://docs.pytest.org/en/7.1.x/) as our test runner. Invoke it with `poetry run python -m pytest`, all other arguments are passed directly to `pytest`. - -#### Unit tests - -Unit tests do not require a Databricks account. - -```bash -poetry run python -m pytest src/databricks/sqlalchemy/test -``` -#### Only a specific test file - -```bash -poetry run python -m pytest src/databricks/sqlalchemy/test/test_suite.py -``` - -#### e2e Tests - -End-to-end tests require a Databricks account. Before you can run them, you must set connection details for a Databricks SQL endpoint in your environment: - -```bash -export host="" -export http_path="" -export access_token="" -export catalog="" -export schema="" -``` - -Or you can write these into a file called `test.env` in the root of the repository: - -``` -host="****.cloud.databricks.com" -http_path="/sql/1.0/warehouses/***" -access_token="dapi***" -staging_ingestion_user="***@example.com" -``` - -To see logging output from pytest while running tests, set `log_cli = "true"` under `tool.pytest.ini_options` in `pyproject.toml`. You can also set `log_cli_level` to any of the default Python log levels: `DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL` - -#### SQLAlchemy dialect tests - -See README.tests.md for details. ### Code formatting diff --git a/README.md b/README.md index 64c20bb..df732a2 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,6 @@ -## Databricks dialect for SQLALchemy 2.0 +## Databricks dialect for SQLALchemy 1.0 -The Databricks dialect for SQLAlchemy serves as bridge between [SQLAlchemy](https://www.sqlalchemy.org/) and the Databricks SQL Python driver. A working example demonstrating usage can be found in `examples/sqlalchemy.py`. - -## Usage with SQLAlchemy <= 2.0 -A SQLAlchemy 1.4 compatible dialect was first released in connector [version 2.4](https://github.com/databricks/databricks-sql-python/releases/tag/v2.4.0). Support for SQLAlchemy 1.4 was dropped from the dialect as part of `databricks-sql-connector==3.0.0`. To continue using the dialect with SQLAlchemy 1.x, you can use `databricks-sql-connector^2.4.0`. +The Databricks dialect for SQLAlchemy serves as bridge between [SQLAlchemy](https://www.sqlalchemy.org/) and the Databricks SQL Python driver. A working example demonstrating usage can be found in `example.py`. ## Installation @@ -11,7 +8,7 @@ A SQLAlchemy 1.4 compatible dialect was first released in connector [version 2.4 To install the dialect and its dependencies: ```shell -pip install databricks-sqlalchemy +pip install databricks-sqlalchemy~=1.0 ``` If you also plan to use `alembic` you can alternatively run: @@ -44,41 +41,45 @@ access_token = os.getenv("DATABRICKS_TOKEN") catalog = os.getenv("DATABRICKS_CATALOG") schema = os.getenv("DATABRICKS_SCHEMA") -engine = create_engine( - f"databricks://token:{access_token}@{host}?http_path={http_path}&catalog={catalog}&schema={schema}" - ) +if sqlalchemy.__version__.startswith("1.3"): + # SQLAlchemy 1.3.x fails to parse the http_path, catalog, and schema from our connection string + # Pass these in as connect_args instead + + conn_string = f"databricks://token:{access_token}@{host}" + connect_args = dict(catalog=catalog, schema=schema, http_path=http_path) + all_connect_args = {**extra_connect_args, **connect_args} + engine = create_engine(conn_string, connect_args=all_connect_args) +else: + engine = create_engine( + f"databricks://token:{access_token}@{host}?http_path={http_path}&catalog={catalog}&schema={schema}", + connect_args=extra_connect_args, + ) + ``` ## Types -The [SQLAlchemy type hierarchy](https://docs.sqlalchemy.org/en/20/core/type_basics.html) contains backend-agnostic type implementations (represented in CamelCase) and backend-specific types (represented in UPPERCASE). The majority of SQLAlchemy's [CamelCase](https://docs.sqlalchemy.org/en/20/core/type_basics.html#the-camelcase-datatypes) types are supported. This means that a SQLAlchemy application using these types should "just work" with Databricks. +The [SQLAlchemy type hierarchy](https://docs.sqlalchemy.org/en/13/core/type_basics.html) contains backend-agnostic type implementations (represented in CamelCase) and backend-specific types (represented in UPPERCASE). The majority of SQLAlchemy's [CamelCase](https://docs.sqlalchemy.org/en/13/core/type_basics.html#the-camelcase-datatypes) types are supported. This means that a SQLAlchemy application using these types should "just work" with Databricks. |SQLAlchemy Type|Databricks SQL Type| |-|-| -[`BigInteger`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.BigInteger)| [`BIGINT`](https://docs.databricks.com/en/sql/language-manual/data-types/bigint-type.html) -[`LargeBinary`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.LargeBinary)| (not supported)| -[`Boolean`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Boolean)| [`BOOLEAN`](https://docs.databricks.com/en/sql/language-manual/data-types/boolean-type.html) -[`Date`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Date)| [`DATE`](https://docs.databricks.com/en/sql/language-manual/data-types/date-type.html) -[`DateTime`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.DateTime)| [`TIMESTAMP_NTZ`](https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-ntz-type.html)| -[`Double`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Double)| [`DOUBLE`](https://docs.databricks.com/en/sql/language-manual/data-types/double-type.html) -[`Enum`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Enum)| (not supported)| -[`Float`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Float)| [`FLOAT`](https://docs.databricks.com/en/sql/language-manual/data-types/float-type.html) -[`Integer`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Integer)| [`INT`](https://docs.databricks.com/en/sql/language-manual/data-types/int-type.html) -[`Numeric`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Numeric)| [`DECIMAL`](https://docs.databricks.com/en/sql/language-manual/data-types/decimal-type.html)| -[`PickleType`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.PickleType)| (not supported)| -[`SmallInteger`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.SmallInteger)| [`SMALLINT`](https://docs.databricks.com/en/sql/language-manual/data-types/smallint-type.html) -[`String`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.String)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| -[`Text`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Text)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| -[`Time`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Time)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| -[`Unicode`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Unicode)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| -[`UnicodeText`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.UnicodeText)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| -[`Uuid`](https://docs.sqlalchemy.org/en/20/core/type_basics.html#sqlalchemy.types.Uuid)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html) - -In addition, the dialect exposes three UPPERCASE SQLAlchemy types which are specific to Databricks: - -- [`databricks.sqlalchemy.TINYINT`](https://docs.databricks.com/en/sql/language-manual/data-types/tinyint-type.html) -- [`databricks.sqlalchemy.TIMESTAMP`](https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-type.html) -- [`databricks.sqlalchemy.TIMESTAMP_NTZ`](https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-ntz-type.html) +[`BigInteger`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.BigInteger)| [`BIGINT`](https://docs.databricks.com/en/sql/language-manual/data-types/bigint-type.html) +[`LargeBinary`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.LargeBinary)| (not supported)| +[`Boolean`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Boolean)| [`BOOLEAN`](https://docs.databricks.com/en/sql/language-manual/data-types/boolean-type.html) +[`Date`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Date)| [`DATE`](https://docs.databricks.com/en/sql/language-manual/data-types/date-type.html) +[`DateTime`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.DateTime)| [`TIMESTAMP_NTZ`](https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-ntz-type.html)| +[`Enum`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Enum)| (not supported)| +[`Float`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Float)| [`FLOAT`](https://docs.databricks.com/en/sql/language-manual/data-types/float-type.html) +[`Integer`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Integer)| [`INT`](https://docs.databricks.com/en/sql/language-manual/data-types/int-type.html) +[`Numeric`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Numeric)| [`DECIMAL`](https://docs.databricks.com/en/sql/language-manual/data-types/decimal-type.html)| +[`PickleType`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.PickleType)| (not supported)| +[`SmallInteger`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.SmallInteger)| [`SMALLINT`](https://docs.databricks.com/en/sql/language-manual/data-types/smallint-type.html) +[`String`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.String)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| +[`Text`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Text)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| +[`Time`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Time)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| +[`Unicode`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Unicode)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| +[`UnicodeText`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.UnicodeText)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)| +[`Uuid`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Uuid)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html) ### `LargeBinary()` and `PickleType()` @@ -91,24 +92,6 @@ Support for `CHECK` constraints is not implemented in this dialect. Support is p SQLAlchemy's `Enum()` type depends on `CHECK` constraints and is therefore not yet supported. -### `DateTime()`, `TIMESTAMP_NTZ()`, and `TIMESTAMP()` - -Databricks Runtime provides two datetime-like types: `TIMESTAMP` which is always timezone-aware and `TIMESTAMP_NTZ` which is timezone agnostic. Both types can be imported from `databricks.sqlalchemy` and used in your models. - -The SQLAlchemy documentation indicates that `DateTime()` is not timezone-aware by default. So our dialect maps this type to `TIMESTAMP_NTZ()`. In practice, you should never need to use `TIMESTAMP_NTZ()` directly. Just use `DateTime()`. - -If you need your field to be timezone-aware, you can import `TIMESTAMP()` and use it instead. - -_Note that SQLAlchemy documentation suggests that you can declare a `DateTime()` with `timezone=True` on supported backends. However, if you do this with the Databricks dialect, the `timezone` argument will be ignored._ - -```python -from sqlalchemy import DateTime -from databricks.sqlalchemy import TIMESTAMP - -class SomeModel(Base): - some_date_without_timezone = DateTime() - some_date_with_timezone = TIMESTAMP() -``` ### `String()`, `Text()`, `Unicode()`, and `UnicodeText()` @@ -133,7 +116,7 @@ class SomeModel(Base): Identity and generated value support is currently limited in this dialect. -When defining models, SQLAlchemy types can accept an [`autoincrement`](https://docs.sqlalchemy.org/en/20/core/metadata.html#sqlalchemy.schema.Column.params.autoincrement) argument. In our dialect, this argument is currently ignored. To create an auto-incrementing field in your model you can pass in an explicit [`Identity()`](https://docs.sqlalchemy.org/en/20/core/defaults.html#identity-ddl) instead. +When defining models, SQLAlchemy types can accept an [`autoincrement`](https://docs.sqlalchemy.org/en/13/core/metadata.html#sqlalchemy.schema.Column.params.autoincrement) argument. In our dialect, this argument is currently ignored. To create an auto-incrementing field in your model you can pass in an explicit [`Identity()`](https://docs.sqlalchemy.org/en/13/core/defaults.html#identity-ddl) instead. Furthermore, in Databricks Runtime, only `BIGINT` fields can be configured to auto-increment. So in SQLAlchemy, you must use the `BigInteger()` type. @@ -147,10 +130,6 @@ class SomeModel(Base): When calling `Base.metadata.create_all()`, the executed DDL will include `GENERATED ALWAYS AS IDENTITY` for the `id` column. This is useful when using SQLAlchemy to generate tables. However, as of this writing, `Identity()` constructs are not captured when SQLAlchemy reflects a table's metadata (support for this is planned). -## Parameters - -`databricks-sql-connector` supports two approaches to parameterizing SQL queries: native and inline. Our SQLAlchemy 2.0 dialect always uses the native approach and is therefore limited to DBR 14.2 and above. If you are writing parameterized queries to be executed by SQLAlchemy, you must use the "named" paramstyle (`:param`). Read more about parameterization in `docs/parameters.md`. - ## Usage with pandas Use [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_sql.html) and [`pandas.read_sql`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql.html#pandas.read_sql) to write and read from Databricks SQL. These methods both accept a SQLAlchemy connection to interact with Databricks. @@ -181,7 +160,7 @@ with engine.connect() as conn: df.to_sql('squares',conn) ``` -## [`PrimaryKey()`](https://docs.sqlalchemy.org/en/20/core/constraints.html#sqlalchemy.schema.PrimaryKeyConstraint) and [`ForeignKey()`](https://docs.sqlalchemy.org/en/20/core/constraints.html#defining-foreign-keys) +## [`PrimaryKey()`](https://docs.sqlalchemy.org/en/13/core/constraints.html#sqlalchemy.schema.PrimaryKeyConstraint) and [`ForeignKey()`](https://docs.sqlalchemy.org/en/13/core/constraints.html#defining-foreign-keys) Unity Catalog workspaces in Databricks support PRIMARY KEY and FOREIGN KEY constraints. _Note that Databricks Runtime does not enforce the integrity of FOREIGN KEY constraints_. You can establish a primary key by setting `primary_key=True` when defining a column. From 4ce0cded1de765174e8542e93a3b4563e1f7f719 Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Tue, 5 Nov 2024 23:35:45 +0530 Subject: [PATCH 03/11] Version changed to 1.0.2 --- pyproject.toml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index c6bc2c8..13d61fc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "databricks-sqlalchemy" -version = "1.0.1" +version = "1.0.2" description = "Databricks SQLAlchemy plugin for Python" authors = ["Databricks "] license = "Apache-2.0" @@ -10,7 +10,6 @@ include = ["CHANGELOG.md"] [tool.poetry.dependencies] python = "^3.8.0" -databricks_sql_connector_core = { version = ">=4.0.0"} sqlalchemy = { version = "^1.3.24" } [tool.poetry.dev-dependencies] From 3dc879f2d7908d9597899635e4296740ef02211e Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Wed, 13 Nov 2024 13:45:35 +0530 Subject: [PATCH 04/11] bumped up to version 1.0.3 --- poetry.lock | 1048 ++++++++++++++++++++++++++++++++++++++++++++++++ pyproject.toml | 3 +- 2 files changed, 1050 insertions(+), 1 deletion(-) create mode 100644 poetry.lock diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000..048bd04 --- /dev/null +++ b/poetry.lock @@ -0,0 +1,1048 @@ +# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand. + +[[package]] +name = "astroid" +version = "3.2.4" +description = "An abstract syntax tree for Python with inference support." +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "astroid-3.2.4-py3-none-any.whl", hash = "sha256:413658a61eeca6202a59231abb473f932038fbcbf1666587f66d482083413a25"}, + {file = "astroid-3.2.4.tar.gz", hash = "sha256:0e14202810b30da1b735827f78f5157be2bbd4a7a59b7707ca0bfc2fb4c0063a"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} + +[[package]] +name = "black" +version = "22.12.0" +description = "The uncompromising code formatter." +optional = false +python-versions = ">=3.7" +files = [ + {file = "black-22.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eedd20838bd5d75b80c9f5487dbcb06836a43833a37846cf1d8c1cc01cef59d"}, + {file = "black-22.12.0-cp310-cp310-win_amd64.whl", hash = "sha256:159a46a4947f73387b4d83e87ea006dbb2337eab6c879620a3ba52699b1f4351"}, + {file = "black-22.12.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d30b212bffeb1e252b31dd269dfae69dd17e06d92b87ad26e23890f3efea366f"}, + {file = "black-22.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:7412e75863aa5c5411886804678b7d083c7c28421210180d67dfd8cf1221e1f4"}, + {file = "black-22.12.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c116eed0efb9ff870ded8b62fe9f28dd61ef6e9ddd28d83d7d264a38417dcee2"}, + {file = "black-22.12.0-cp37-cp37m-win_amd64.whl", hash = "sha256:1f58cbe16dfe8c12b7434e50ff889fa479072096d79f0a7f25e4ab8e94cd8350"}, + {file = "black-22.12.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77d86c9f3db9b1bf6761244bc0b3572a546f5fe37917a044e02f3166d5aafa7d"}, + {file = "black-22.12.0-cp38-cp38-win_amd64.whl", hash = "sha256:82d9fe8fee3401e02e79767016b4907820a7dc28d70d137eb397b92ef3cc5bfc"}, + {file = "black-22.12.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:101c69b23df9b44247bd88e1d7e90154336ac4992502d4197bdac35dd7ee3320"}, + {file = "black-22.12.0-cp39-cp39-win_amd64.whl", hash = "sha256:559c7a1ba9a006226f09e4916060982fd27334ae1998e7a38b3f33a37f7a2148"}, + {file = "black-22.12.0-py3-none-any.whl", hash = "sha256:436cc9167dd28040ad90d3b404aec22cedf24a6e4d7de221bec2730ec0c97bcf"}, + {file = "black-22.12.0.tar.gz", hash = "sha256:229351e5a18ca30f447bf724d007f890f97e13af070bb6ad4c0a441cd7596a2f"}, +] + +[package.dependencies] +click = ">=8.0.0" +mypy-extensions = ">=0.4.3" +pathspec = ">=0.9.0" +platformdirs = ">=2" +tomli = {version = ">=1.1.0", markers = "python_full_version < \"3.11.0a7\""} +typing-extensions = {version = ">=3.10.0.0", markers = "python_version < \"3.10\""} + +[package.extras] +colorama = ["colorama (>=0.4.3)"] +d = ["aiohttp (>=3.7.4)"] +jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] +uvloop = ["uvloop (>=0.15.2)"] + +[[package]] +name = "certifi" +version = "2024.8.30" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, + {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.0" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4f9fc98dad6c2eaa32fc3af1417d95b5e3d08aff968df0cd320066def971f9a6"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0de7b687289d3c1b3e8660d0741874abe7888100efe14bd0f9fd7141bcbda92b"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ed2e36c3e9b4f21dd9422f6893dec0abf2cca553af509b10cd630f878d3eb99"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d3ff7fc90b98c637bda91c89d51264a3dcf210cade3a2c6f838c7268d7a4ca"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1110e22af8ca26b90bd6364fe4c763329b0ebf1ee213ba32b68c73de5752323d"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86f4e8cca779080f66ff4f191a685ced73d2f72d50216f7112185dc02b90b9b7"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f683ddc7eedd742e2889d2bfb96d69573fde1d92fcb811979cdb7165bb9c7d3"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27623ba66c183eca01bf9ff833875b459cad267aeeb044477fedac35e19ba907"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f606a1881d2663630ea5b8ce2efe2111740df4b687bd78b34a8131baa007f79b"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0b309d1747110feb25d7ed6b01afdec269c647d382c857ef4663bbe6ad95a912"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:136815f06a3ae311fae551c3df1f998a1ebd01ddd424aa5603a4336997629e95"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:14215b71a762336254351b00ec720a8e85cada43b987da5a042e4ce3e82bd68e"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79983512b108e4a164b9c8d34de3992f76d48cadc9554c9e60b43f308988aabe"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-win32.whl", hash = "sha256:c94057af19bc953643a33581844649a7fdab902624d2eb739738a30e2b3e60fc"}, + {file = "charset_normalizer-3.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:55f56e2ebd4e3bc50442fbc0888c9d8c94e4e06a933804e2af3e89e2f9c1c749"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-win32.whl", hash = "sha256:9ae4ef0b3f6b41bad6366fb0ea4fc1d7ed051528e113a60fa2a65a9abb5b1d99"}, + {file = "charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7"}, + {file = "charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67"}, + {file = "charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:dbe03226baf438ac4fda9e2d0715022fd579cb641c4cf639fa40d53b2fe6f3e2"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd9a8bd8900e65504a305bf8ae6fa9fbc66de94178c420791d0293702fce2df7"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b8831399554b92b72af5932cdbbd4ddc55c55f631bb13ff8fe4e6536a06c5c51"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a14969b8691f7998e74663b77b4c36c0337cb1df552da83d5c9004a93afdb574"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dcaf7c1524c0542ee2fc82cc8ec337f7a9f7edee2532421ab200d2b920fc97cf"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:425c5f215d0eecee9a56cdb703203dda90423247421bf0d67125add85d0c4455"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:d5b054862739d276e09928de37c79ddeec42a6e1bfc55863be96a36ba22926f6"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:f3e73a4255342d4eb26ef6df01e3962e73aa29baa3124a8e824c5d3364a65748"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:2f6c34da58ea9c1a9515621f4d9ac379871a8f21168ba1b5e09d74250de5ad62"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:f09cb5a7bbe1ecae6e87901a2eb23e0256bb524a79ccc53eb0b7629fbe7677c4"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:0099d79bdfcf5c1f0c2c72f91516702ebf8b0b8ddd8905f97a8aecf49712c621"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-win32.whl", hash = "sha256:9c98230f5042f4945f957d006edccc2af1e03ed5e37ce7c373f00a5a4daa6149"}, + {file = "charset_normalizer-3.4.0-cp37-cp37m-win_amd64.whl", hash = "sha256:62f60aebecfc7f4b82e3f639a7d1433a20ec32824db2199a11ad4f5e146ef5ee"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:af73657b7a68211996527dbfeffbb0864e043d270580c5aef06dc4b659a4b578"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:cab5d0b79d987c67f3b9e9c53f54a61360422a5a0bc075f43cab5621d530c3b6"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9289fd5dddcf57bab41d044f1756550f9e7cf0c8e373b8cdf0ce8773dc4bd417"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b493a043635eb376e50eedf7818f2f322eabbaa974e948bd8bdd29eb7ef2a51"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fa2566ca27d67c86569e8c85297aaf413ffab85a8960500f12ea34ff98e4c41"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8e538f46104c815be19c975572d74afb53f29650ea2025bbfaef359d2de2f7f"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fd30dc99682dc2c603c2b315bded2799019cea829f8bf57dc6b61efde6611c8"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2006769bd1640bdf4d5641c69a3d63b71b81445473cac5ded39740a226fa88ab"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:dc15e99b2d8a656f8e666854404f1ba54765871104e50c8e9813af8a7db07f12"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:ab2e5bef076f5a235c3774b4f4028a680432cded7cad37bba0fd90d64b187d19"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:4ec9dd88a5b71abfc74e9df5ebe7921c35cbb3b641181a531ca65cdb5e8e4dea"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:43193c5cda5d612f247172016c4bb71251c784d7a4d9314677186a838ad34858"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:aa693779a8b50cd97570e5a0f343538a8dbd3e496fa5dcb87e29406ad0299654"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-win32.whl", hash = "sha256:7706f5850360ac01d80c89bcef1640683cc12ed87f42579dab6c5d3ed6888613"}, + {file = "charset_normalizer-3.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:c3e446d253bd88f6377260d07c895816ebf33ffffd56c1c792b13bff9c3e1ade"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:980b4f289d1d90ca5efcf07958d3eb38ed9c0b7676bf2831a54d4f66f9c27dfa"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f28f891ccd15c514a0981f3b9db9aa23d62fe1a99997512b0491d2ed323d229a"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8aacce6e2e1edcb6ac625fb0f8c3a9570ccc7bfba1f63419b3769ccf6a00ed0"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd7af3717683bea4c87acd8c0d3d5b44d56120b26fd3f8a692bdd2d5260c620a"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ff2ed8194587faf56555927b3aa10e6fb69d931e33953943bc4f837dfee2242"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e91f541a85298cf35433bf66f3fab2a4a2cff05c127eeca4af174f6d497f0d4b"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:309a7de0a0ff3040acaebb35ec45d18db4b28232f21998851cfa709eeff49d62"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:285e96d9d53422efc0d7a17c60e59f37fbf3dfa942073f666db4ac71e8d726d0"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5d447056e2ca60382d460a604b6302d8db69476fd2015c81e7c35417cfabe4cd"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:20587d20f557fe189b7947d8e7ec5afa110ccf72a3128d61a2a387c3313f46be"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:130272c698667a982a5d0e626851ceff662565379baf0ff2cc58067b81d4f11d"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:ab22fbd9765e6954bc0bcff24c25ff71dcbfdb185fcdaca49e81bac68fe724d3"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7782afc9b6b42200f7362858f9e73b1f8316afb276d316336c0ec3bd73312742"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-win32.whl", hash = "sha256:2de62e8801ddfff069cd5c504ce3bc9672b23266597d4e4f50eda28846c322f2"}, + {file = "charset_normalizer-3.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:95c3c157765b031331dd4db3c775e58deaee050a3042fcad72cbc4189d7c8dca"}, + {file = "charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079"}, + {file = "charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e"}, +] + +[[package]] +name = "click" +version = "8.1.7" +description = "Composable command line interface toolkit" +optional = false +python-versions = ">=3.7" +files = [ + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "databricks-sql-connector" +version = "4.0.0b4" +description = "Databricks SQL Connector for Python" +optional = false +python-versions = "<4.0.0,>=3.8.0" +files = [ + {file = "databricks_sql_connector-4.0.0b4-py3-none-any.whl", hash = "sha256:e5f8e9bf3e73405190879b3c9d4962b2a19aaeeb5892ac3130189091e53d7104"}, + {file = "databricks_sql_connector-4.0.0b4.tar.gz", hash = "sha256:465e50aed29d7947fcd664f09d8b056157bbe7988e1518cbec08a53921c48774"}, +] + +[package.dependencies] +lz4 = ">=4.0.2,<5.0.0" +numpy = [ + {version = ">=1.16.6,<2.0.0", markers = "python_version >= \"3.8\" and python_version < \"3.11\""}, + {version = ">=1.23.4,<2.0.0", markers = "python_version >= \"3.11\""}, +] +oauthlib = ">=3.1.0,<4.0.0" +openpyxl = ">=3.0.10,<4.0.0" +pandas = {version = ">=1.2.5,<2.3.0", markers = "python_version >= \"3.8\""} +requests = ">=2.18.1,<3.0.0" +thrift = ">=0.16.0,<0.21.0" +urllib3 = ">=1.26" + +[package.extras] +pyarrow = ["pyarrow (>=14.0.1,<17)"] + +[[package]] +name = "dill" +version = "0.3.9" +description = "serialize all of Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "dill-0.3.9-py3-none-any.whl", hash = "sha256:468dff3b89520b474c0397703366b7b95eebe6303f108adf9b19da1f702be87a"}, + {file = "dill-0.3.9.tar.gz", hash = "sha256:81aa267dddf68cbfe8029c42ca9ec6a4ab3b22371d1c450abc54422577b4512c"}, +] + +[package.extras] +graph = ["objgraph (>=1.7.2)"] +profile = ["gprof2dot (>=2022.7.29)"] + +[[package]] +name = "et-xmlfile" +version = "2.0.0" +description = "An implementation of lxml.xmlfile for the standard library" +optional = false +python-versions = ">=3.8" +files = [ + {file = "et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa"}, + {file = "et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.2" +description = "Backport of PEP 654 (exception groups)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, +] + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "greenlet" +version = "3.1.1" +description = "Lightweight in-process concurrent programming" +optional = false +python-versions = ">=3.7" +files = [ + {file = "greenlet-3.1.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:0bbae94a29c9e5c7e4a2b7f0aae5c17e8e90acbfd3bf6270eeba60c39fce3563"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fde093fb93f35ca72a556cf72c92ea3ebfda3d79fc35bb19fbe685853869a83"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36b89d13c49216cadb828db8dfa6ce86bbbc476a82d3a6c397f0efae0525bdd0"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94b6150a85e1b33b40b1464a3f9988dcc5251d6ed06842abff82e42632fac120"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93147c513fac16385d1036b7e5b102c7fbbdb163d556b791f0f11eada7ba65dc"}, + {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da7a9bff22ce038e19bf62c4dd1ec8391062878710ded0a845bcf47cc0200617"}, + {file = "greenlet-3.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b2795058c23988728eec1f36a4e5e4ebad22f8320c85f3587b539b9ac84128d7"}, + {file = "greenlet-3.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ed10eac5830befbdd0c32f83e8aa6288361597550ba669b04c48f0f9a2c843c6"}, + {file = "greenlet-3.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:77c386de38a60d1dfb8e55b8c1101d68c79dfdd25c7095d51fec2dd800892b80"}, + {file = "greenlet-3.1.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e4d333e558953648ca09d64f13e6d8f0523fa705f51cae3f03b5983489958c70"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09fc016b73c94e98e29af67ab7b9a879c307c6731a2c9da0db5a7d9b7edd1159"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d5e975ca70269d66d17dd995dafc06f1b06e8cb1ec1e9ed54c1d1e4a7c4cf26e"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b2813dc3de8c1ee3f924e4d4227999285fd335d1bcc0d2be6dc3f1f6a318ec1"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e347b3bfcf985a05e8c0b7d462ba6f15b1ee1c909e2dcad795e49e91b152c383"}, + {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e8f8c9cb53cdac7ba9793c276acd90168f416b9ce36799b9b885790f8ad6c0a"}, + {file = "greenlet-3.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:62ee94988d6b4722ce0028644418d93a52429e977d742ca2ccbe1c4f4a792511"}, + {file = "greenlet-3.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1776fd7f989fc6b8d8c8cb8da1f6b82c5814957264d1f6cf818d475ec2bf6395"}, + {file = "greenlet-3.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:48ca08c771c268a768087b408658e216133aecd835c0ded47ce955381105ba39"}, + {file = "greenlet-3.1.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:4afe7ea89de619adc868e087b4d2359282058479d7cfb94970adf4b55284574d"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f406b22b7c9a9b4f8aa9d2ab13d6ae0ac3e85c9a809bd590ad53fed2bf70dc79"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c3a701fe5a9695b238503ce5bbe8218e03c3bcccf7e204e455e7462d770268aa"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2846930c65b47d70b9d178e89c7e1a69c95c1f68ea5aa0a58646b7a96df12441"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99cfaa2110534e2cf3ba31a7abcac9d328d1d9f1b95beede58294a60348fba36"}, + {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1443279c19fca463fc33e65ef2a935a5b09bb90f978beab37729e1c3c6c25fe9"}, + {file = "greenlet-3.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b7cede291382a78f7bb5f04a529cb18e068dd29e0fb27376074b6d0317bf4dd0"}, + {file = "greenlet-3.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:23f20bb60ae298d7d8656c6ec6db134bca379ecefadb0b19ce6f19d1f232a942"}, + {file = "greenlet-3.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:7124e16b4c55d417577c2077be379514321916d5790fa287c9ed6f23bd2ffd01"}, + {file = "greenlet-3.1.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:05175c27cb459dcfc05d026c4232f9de8913ed006d42713cb8a5137bd49375f1"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:935e943ec47c4afab8965954bf49bfa639c05d4ccf9ef6e924188f762145c0ff"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:667a9706c970cb552ede35aee17339a18e8f2a87a51fba2ed39ceeeb1004798a"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8a678974d1f3aa55f6cc34dc480169d58f2e6d8958895d68845fa4ab566509e"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efc0f674aa41b92da8c49e0346318c6075d734994c3c4e4430b1c3f853e498e4"}, + {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0153404a4bb921f0ff1abeb5ce8a5131da56b953eda6e14b88dc6bbc04d2049e"}, + {file = "greenlet-3.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:275f72decf9932639c1c6dd1013a1bc266438eb32710016a1c742df5da6e60a1"}, + {file = "greenlet-3.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c4aab7f6381f38a4b42f269057aee279ab0fc7bf2e929e3d4abfae97b682a12c"}, + {file = "greenlet-3.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:b42703b1cf69f2aa1df7d1030b9d77d3e584a70755674d60e710f0af570f3761"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1695e76146579f8c06c1509c7ce4dfe0706f49c6831a817ac04eebb2fd02011"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7876452af029456b3f3549b696bb36a06db7c90747740c5302f74a9e9fa14b13"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4ead44c85f8ab905852d3de8d86f6f8baf77109f9da589cb4fa142bd3b57b475"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8320f64b777d00dd7ccdade271eaf0cad6636343293a25074cc5566160e4de7b"}, + {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6510bf84a6b643dabba74d3049ead221257603a253d0a9873f55f6a59a65f822"}, + {file = "greenlet-3.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:04b013dc07c96f83134b1e99888e7a79979f1a247e2a9f59697fa14b5862ed01"}, + {file = "greenlet-3.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:411f015496fec93c1c8cd4e5238da364e1da7a124bcb293f085bf2860c32c6f6"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47da355d8687fd65240c364c90a31569a133b7b60de111c255ef5b606f2ae291"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:98884ecf2ffb7d7fe6bd517e8eb99d31ff7855a840fa6d0d63cd07c037f6a981"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1d4aeb8891338e60d1ab6127af1fe45def5259def8094b9c7e34690c8858803"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db32b5348615a04b82240cc67983cb315309e88d444a288934ee6ceaebcad6cc"}, + {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dcc62f31eae24de7f8dce72134c8651c58000d3b1868e01392baea7c32c247de"}, + {file = "greenlet-3.1.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:1d3755bcb2e02de341c55b4fca7a745a24a9e7212ac953f6b3a48d117d7257aa"}, + {file = "greenlet-3.1.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:b8da394b34370874b4572676f36acabac172602abf054cbc4ac910219f3340af"}, + {file = "greenlet-3.1.1-cp37-cp37m-win32.whl", hash = "sha256:a0dfc6c143b519113354e780a50381508139b07d2177cb6ad6a08278ec655798"}, + {file = "greenlet-3.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:54558ea205654b50c438029505def3834e80f0869a70fb15b871c29b4575ddef"}, + {file = "greenlet-3.1.1-cp38-cp38-macosx_11_0_universal2.whl", hash = "sha256:346bed03fe47414091be4ad44786d1bd8bef0c3fcad6ed3dee074a032ab408a9"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfc59d69fc48664bc693842bd57acfdd490acafda1ab52c7836e3fc75c90a111"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d21e10da6ec19b457b82636209cbe2331ff4306b54d06fa04b7c138ba18c8a81"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:37b9de5a96111fc15418819ab4c4432e4f3c2ede61e660b1e33971eba26ef9ba"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ef9ea3f137e5711f0dbe5f9263e8c009b7069d8a1acea822bd5e9dae0ae49c8"}, + {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85f3ff71e2e60bd4b4932a043fbbe0f499e263c628390b285cb599154a3b03b1"}, + {file = "greenlet-3.1.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:95ffcf719966dd7c453f908e208e14cde192e09fde6c7186c8f1896ef778d8cd"}, + {file = "greenlet-3.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:03a088b9de532cbfe2ba2034b2b85e82df37874681e8c470d6fb2f8c04d7e4b7"}, + {file = "greenlet-3.1.1-cp38-cp38-win32.whl", hash = "sha256:8b8b36671f10ba80e159378df9c4f15c14098c4fd73a36b9ad715f057272fbef"}, + {file = "greenlet-3.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:7017b2be767b9d43cc31416aba48aab0d2309ee31b4dbf10a1d38fb7972bdf9d"}, + {file = "greenlet-3.1.1-cp39-cp39-macosx_11_0_universal2.whl", hash = "sha256:396979749bd95f018296af156201d6211240e7a23090f50a8d5d18c370084dc3"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca9d0ff5ad43e785350894d97e13633a66e2b50000e8a183a50a88d834752d42"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f6ff3b14f2df4c41660a7dec01045a045653998784bf8cfcb5a525bdffffbc8f"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94ebba31df2aa506d7b14866fed00ac141a867e63143fe5bca82a8e503b36437"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:73aaad12ac0ff500f62cebed98d8789198ea0e6f233421059fa68a5aa7220145"}, + {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63e4844797b975b9af3a3fb8f7866ff08775f5426925e1e0bbcfe7932059a12c"}, + {file = "greenlet-3.1.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7939aa3ca7d2a1593596e7ac6d59391ff30281ef280d8632fa03d81f7c5f955e"}, + {file = "greenlet-3.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d0028e725ee18175c6e422797c407874da24381ce0690d6b9396c204c7f7276e"}, + {file = "greenlet-3.1.1-cp39-cp39-win32.whl", hash = "sha256:5e06afd14cbaf9e00899fae69b24a32f2196c19de08fcb9f4779dd4f004e5e7c"}, + {file = "greenlet-3.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:3319aa75e0e0639bc15ff54ca327e8dc7a6fe404003496e3c6925cd3142e0e22"}, + {file = "greenlet-3.1.1.tar.gz", hash = "sha256:4ce3ac6cdb6adf7946475d7ef31777c26d94bccc377e070a7986bd2d5c515467"}, +] + +[package.extras] +docs = ["Sphinx", "furo"] +test = ["objgraph", "psutil"] + +[[package]] +name = "idna" +version = "3.10" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.6" +files = [ + {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"}, + {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"}, +] + +[package.extras] +all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"] + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "isort" +version = "5.13.2" +description = "A Python utility / library to sort Python imports." +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6"}, + {file = "isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109"}, +] + +[package.extras] +colors = ["colorama (>=0.4.6)"] + +[[package]] +name = "lz4" +version = "4.3.3" +description = "LZ4 Bindings for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "lz4-4.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b891880c187e96339474af2a3b2bfb11a8e4732ff5034be919aa9029484cd201"}, + {file = "lz4-4.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:222a7e35137d7539c9c33bb53fcbb26510c5748779364014235afc62b0ec797f"}, + {file = "lz4-4.3.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f76176492ff082657ada0d0f10c794b6da5800249ef1692b35cf49b1e93e8ef7"}, + {file = "lz4-4.3.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f1d18718f9d78182c6b60f568c9a9cec8a7204d7cb6fad4e511a2ef279e4cb05"}, + {file = "lz4-4.3.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6cdc60e21ec70266947a48839b437d46025076eb4b12c76bd47f8e5eb8a75dcc"}, + {file = "lz4-4.3.3-cp310-cp310-win32.whl", hash = "sha256:c81703b12475da73a5d66618856d04b1307e43428a7e59d98cfe5a5d608a74c6"}, + {file = "lz4-4.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:43cf03059c0f941b772c8aeb42a0813d68d7081c009542301637e5782f8a33e2"}, + {file = "lz4-4.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:30e8c20b8857adef7be045c65f47ab1e2c4fabba86a9fa9a997d7674a31ea6b6"}, + {file = "lz4-4.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2f7b1839f795315e480fb87d9bc60b186a98e3e5d17203c6e757611ef7dcef61"}, + {file = "lz4-4.3.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edfd858985c23523f4e5a7526ca6ee65ff930207a7ec8a8f57a01eae506aaee7"}, + {file = "lz4-4.3.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e9c410b11a31dbdc94c05ac3c480cb4b222460faf9231f12538d0074e56c563"}, + {file = "lz4-4.3.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d2507ee9c99dbddd191c86f0e0c8b724c76d26b0602db9ea23232304382e1f21"}, + {file = "lz4-4.3.3-cp311-cp311-win32.whl", hash = "sha256:f180904f33bdd1e92967923a43c22899e303906d19b2cf8bb547db6653ea6e7d"}, + {file = "lz4-4.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:b14d948e6dce389f9a7afc666d60dd1e35fa2138a8ec5306d30cd2e30d36b40c"}, + {file = "lz4-4.3.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:e36cd7b9d4d920d3bfc2369840da506fa68258f7bb176b8743189793c055e43d"}, + {file = "lz4-4.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:31ea4be9d0059c00b2572d700bf2c1bc82f241f2c3282034a759c9a4d6ca4dc2"}, + {file = "lz4-4.3.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33c9a6fd20767ccaf70649982f8f3eeb0884035c150c0b818ea660152cf3c809"}, + {file = "lz4-4.3.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca8fccc15e3add173da91be8f34121578dc777711ffd98d399be35487c934bf"}, + {file = "lz4-4.3.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7d84b479ddf39fe3ea05387f10b779155fc0990125f4fb35d636114e1c63a2e"}, + {file = "lz4-4.3.3-cp312-cp312-win32.whl", hash = "sha256:337cb94488a1b060ef1685187d6ad4ba8bc61d26d631d7ba909ee984ea736be1"}, + {file = "lz4-4.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:5d35533bf2cee56f38ced91f766cd0038b6abf46f438a80d50c52750088be93f"}, + {file = "lz4-4.3.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:363ab65bf31338eb364062a15f302fc0fab0a49426051429866d71c793c23394"}, + {file = "lz4-4.3.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:0a136e44a16fc98b1abc404fbabf7f1fada2bdab6a7e970974fb81cf55b636d0"}, + {file = "lz4-4.3.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:abc197e4aca8b63f5ae200af03eb95fb4b5055a8f990079b5bdf042f568469dd"}, + {file = "lz4-4.3.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:56f4fe9c6327adb97406f27a66420b22ce02d71a5c365c48d6b656b4aaeb7775"}, + {file = "lz4-4.3.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f0e822cd7644995d9ba248cb4b67859701748a93e2ab7fc9bc18c599a52e4604"}, + {file = "lz4-4.3.3-cp38-cp38-win32.whl", hash = "sha256:24b3206de56b7a537eda3a8123c644a2b7bf111f0af53bc14bed90ce5562d1aa"}, + {file = "lz4-4.3.3-cp38-cp38-win_amd64.whl", hash = "sha256:b47839b53956e2737229d70714f1d75f33e8ac26e52c267f0197b3189ca6de24"}, + {file = "lz4-4.3.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6756212507405f270b66b3ff7f564618de0606395c0fe10a7ae2ffcbbe0b1fba"}, + {file = "lz4-4.3.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ee9ff50557a942d187ec85462bb0960207e7ec5b19b3b48949263993771c6205"}, + {file = "lz4-4.3.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2b901c7784caac9a1ded4555258207d9e9697e746cc8532129f150ffe1f6ba0d"}, + {file = "lz4-4.3.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6d9ec061b9eca86e4dcc003d93334b95d53909afd5a32c6e4f222157b50c071"}, + {file = "lz4-4.3.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f4c7bf687303ca47d69f9f0133274958fd672efaa33fb5bcde467862d6c621f0"}, + {file = "lz4-4.3.3-cp39-cp39-win32.whl", hash = "sha256:054b4631a355606e99a42396f5db4d22046a3397ffc3269a348ec41eaebd69d2"}, + {file = "lz4-4.3.3-cp39-cp39-win_amd64.whl", hash = "sha256:eac9af361e0d98335a02ff12fb56caeb7ea1196cf1a49dbf6f17828a131da807"}, + {file = "lz4-4.3.3.tar.gz", hash = "sha256:01fe674ef2889dbb9899d8a67361e0c4a2c833af5aeb37dd505727cf5d2a131e"}, +] + +[package.extras] +docs = ["sphinx (>=1.6.0)", "sphinx-bootstrap-theme"] +flake8 = ["flake8"] +tests = ["psutil", "pytest (!=3.3.0)", "pytest-cov"] + +[[package]] +name = "mccabe" +version = "0.7.0" +description = "McCabe checker, plugin for flake8" +optional = false +python-versions = ">=3.6" +files = [ + {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"}, + {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"}, +] + +[[package]] +name = "mypy" +version = "1.13.0" +description = "Optional static typing for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "mypy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6607e0f1dd1fb7f0aca14d936d13fd19eba5e17e1cd2a14f808fa5f8f6d8f60a"}, + {file = "mypy-1.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a21be69bd26fa81b1f80a61ee7ab05b076c674d9b18fb56239d72e21d9f4c80"}, + {file = "mypy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b2353a44d2179846a096e25691d54d59904559f4232519d420d64da6828a3a7"}, + {file = "mypy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0730d1c6a2739d4511dc4253f8274cdd140c55c32dfb0a4cf8b7a43f40abfa6f"}, + {file = "mypy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:c5fc54dbb712ff5e5a0fca797e6e0aa25726c7e72c6a5850cfd2adbc1eb0a372"}, + {file = "mypy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:581665e6f3a8a9078f28d5502f4c334c0c8d802ef55ea0e7276a6e409bc0d82d"}, + {file = "mypy-1.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3ddb5b9bf82e05cc9a627e84707b528e5c7caaa1c55c69e175abb15a761cec2d"}, + {file = "mypy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20c7ee0bc0d5a9595c46f38beb04201f2620065a93755704e141fcac9f59db2b"}, + {file = "mypy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3790ded76f0b34bc9c8ba4def8f919dd6a46db0f5a6610fb994fe8efdd447f73"}, + {file = "mypy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51f869f4b6b538229c1d1bcc1dd7d119817206e2bc54e8e374b3dfa202defcca"}, + {file = "mypy-1.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5c7051a3461ae84dfb5dd15eff5094640c61c5f22257c8b766794e6dd85e72d5"}, + {file = "mypy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:39bb21c69a5d6342f4ce526e4584bc5c197fd20a60d14a8624d8743fffb9472e"}, + {file = "mypy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:164f28cb9d6367439031f4c81e84d3ccaa1e19232d9d05d37cb0bd880d3f93c2"}, + {file = "mypy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a4c1bfcdbce96ff5d96fc9b08e3831acb30dc44ab02671eca5953eadad07d6d0"}, + {file = "mypy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:a0affb3a79a256b4183ba09811e3577c5163ed06685e4d4b46429a271ba174d2"}, + {file = "mypy-1.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a7b44178c9760ce1a43f544e595d35ed61ac2c3de306599fa59b38a6048e1aa7"}, + {file = "mypy-1.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d5092efb8516d08440e36626f0153b5006d4088c1d663d88bf79625af3d1d62"}, + {file = "mypy-1.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2904956dac40ced10931ac967ae63c5089bd498542194b436eb097a9f77bc8"}, + {file = "mypy-1.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7bfd8836970d33c2105562650656b6846149374dc8ed77d98424b40b09340ba7"}, + {file = "mypy-1.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:9f73dba9ec77acb86457a8fc04b5239822df0c14a082564737833d2963677dbc"}, + {file = "mypy-1.13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:100fac22ce82925f676a734af0db922ecfea991e1d7ec0ceb1e115ebe501301a"}, + {file = "mypy-1.13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7bcb0bb7f42a978bb323a7c88f1081d1b5dee77ca86f4100735a6f541299d8fb"}, + {file = "mypy-1.13.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bde31fc887c213e223bbfc34328070996061b0833b0a4cfec53745ed61f3519b"}, + {file = "mypy-1.13.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:07de989f89786f62b937851295ed62e51774722e5444a27cecca993fc3f9cd74"}, + {file = "mypy-1.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:4bde84334fbe19bad704b3f5b78c4abd35ff1026f8ba72b29de70dda0916beb6"}, + {file = "mypy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0246bcb1b5de7f08f2826451abd947bf656945209b140d16ed317f65a17dc7dc"}, + {file = "mypy-1.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f5b7deae912cf8b77e990b9280f170381fdfbddf61b4ef80927edd813163732"}, + {file = "mypy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7029881ec6ffb8bc233a4fa364736789582c738217b133f1b55967115288a2bc"}, + {file = "mypy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3e38b980e5681f28f033f3be86b099a247b13c491f14bb8b1e1e134d23bb599d"}, + {file = "mypy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:a6789be98a2017c912ae6ccb77ea553bbaf13d27605d2ca20a76dfbced631b24"}, + {file = "mypy-1.13.0-py3-none-any.whl", hash = "sha256:9c250883f9fd81d212e0952c92dbfcc96fc237f4b7c92f56ac81fd48460b3e5a"}, + {file = "mypy-1.13.0.tar.gz", hash = "sha256:0291a61b6fbf3e6673e3405cfcc0e7650bebc7939659fdca2702958038bd835e"}, +] + +[package.dependencies] +mypy-extensions = ">=1.0.0" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = ">=4.6.0" + +[package.extras] +dmypy = ["psutil (>=4.0)"] +faster-cache = ["orjson"] +install-types = ["pip"] +mypyc = ["setuptools (>=50)"] +reports = ["lxml"] + +[[package]] +name = "mypy-extensions" +version = "1.0.0" +description = "Type system extensions for programs checked with the mypy type checker." +optional = false +python-versions = ">=3.5" +files = [ + {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, + {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, +] + +[[package]] +name = "numpy" +version = "1.24.4" +description = "Fundamental package for array computing in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "numpy-1.24.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c0bfb52d2169d58c1cdb8cc1f16989101639b34c7d3ce60ed70b19c63eba0b64"}, + {file = "numpy-1.24.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ed094d4f0c177b1b8e7aa9cba7d6ceed51c0e569a5318ac0ca9a090680a6a1b1"}, + {file = "numpy-1.24.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79fc682a374c4a8ed08b331bef9c5f582585d1048fa6d80bc6c35bc384eee9b4"}, + {file = "numpy-1.24.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ffe43c74893dbf38c2b0a1f5428760a1a9c98285553c89e12d70a96a7f3a4d6"}, + {file = "numpy-1.24.4-cp310-cp310-win32.whl", hash = "sha256:4c21decb6ea94057331e111a5bed9a79d335658c27ce2adb580fb4d54f2ad9bc"}, + {file = "numpy-1.24.4-cp310-cp310-win_amd64.whl", hash = "sha256:b4bea75e47d9586d31e892a7401f76e909712a0fd510f58f5337bea9572c571e"}, + {file = "numpy-1.24.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f136bab9c2cfd8da131132c2cf6cc27331dd6fae65f95f69dcd4ae3c3639c810"}, + {file = "numpy-1.24.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2926dac25b313635e4d6cf4dc4e51c8c0ebfed60b801c799ffc4c32bf3d1254"}, + {file = "numpy-1.24.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:222e40d0e2548690405b0b3c7b21d1169117391c2e82c378467ef9ab4c8f0da7"}, + {file = "numpy-1.24.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7215847ce88a85ce39baf9e89070cb860c98fdddacbaa6c0da3ffb31b3350bd5"}, + {file = "numpy-1.24.4-cp311-cp311-win32.whl", hash = "sha256:4979217d7de511a8d57f4b4b5b2b965f707768440c17cb70fbf254c4b225238d"}, + {file = "numpy-1.24.4-cp311-cp311-win_amd64.whl", hash = "sha256:b7b1fc9864d7d39e28f41d089bfd6353cb5f27ecd9905348c24187a768c79694"}, + {file = "numpy-1.24.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1452241c290f3e2a312c137a9999cdbf63f78864d63c79039bda65ee86943f61"}, + {file = "numpy-1.24.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:04640dab83f7c6c85abf9cd729c5b65f1ebd0ccf9de90b270cd61935eef0197f"}, + {file = "numpy-1.24.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5425b114831d1e77e4b5d812b69d11d962e104095a5b9c3b641a218abcc050e"}, + {file = "numpy-1.24.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd80e219fd4c71fc3699fc1dadac5dcf4fd882bfc6f7ec53d30fa197b8ee22dc"}, + {file = "numpy-1.24.4-cp38-cp38-win32.whl", hash = "sha256:4602244f345453db537be5314d3983dbf5834a9701b7723ec28923e2889e0bb2"}, + {file = "numpy-1.24.4-cp38-cp38-win_amd64.whl", hash = "sha256:692f2e0f55794943c5bfff12b3f56f99af76f902fc47487bdfe97856de51a706"}, + {file = "numpy-1.24.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2541312fbf09977f3b3ad449c4e5f4bb55d0dbf79226d7724211acc905049400"}, + {file = "numpy-1.24.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9667575fb6d13c95f1b36aca12c5ee3356bf001b714fc354eb5465ce1609e62f"}, + {file = "numpy-1.24.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a86ed21e4f87050382c7bc96571755193c4c1392490744ac73d660e8f564a9"}, + {file = "numpy-1.24.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d11efb4dbecbdf22508d55e48d9c8384db795e1b7b51ea735289ff96613ff74d"}, + {file = "numpy-1.24.4-cp39-cp39-win32.whl", hash = "sha256:6620c0acd41dbcb368610bb2f4d83145674040025e5536954782467100aa8835"}, + {file = "numpy-1.24.4-cp39-cp39-win_amd64.whl", hash = "sha256:befe2bf740fd8373cf56149a5c23a0f601e82869598d41f8e188a0e9869926f8"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:31f13e25b4e304632a4619d0e0777662c2ffea99fcae2029556b17d8ff958aef"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95f7ac6540e95bc440ad77f56e520da5bf877f87dca58bd095288dce8940532a"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e98f220aa76ca2a977fe435f5b04d7b3470c0a2e6312907b37ba6068f26787f2"}, + {file = "numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463"}, +] + +[[package]] +name = "numpy" +version = "1.26.4" +description = "Fundamental package for array computing in Python" +optional = false +python-versions = ">=3.9" +files = [ + {file = "numpy-1.26.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0"}, + {file = "numpy-1.26.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4"}, + {file = "numpy-1.26.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a"}, + {file = "numpy-1.26.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2"}, + {file = "numpy-1.26.4-cp310-cp310-win32.whl", hash = "sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07"}, + {file = "numpy-1.26.4-cp310-cp310-win_amd64.whl", hash = "sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71"}, + {file = "numpy-1.26.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e"}, + {file = "numpy-1.26.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a"}, + {file = "numpy-1.26.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a"}, + {file = "numpy-1.26.4-cp311-cp311-win32.whl", hash = "sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20"}, + {file = "numpy-1.26.4-cp311-cp311-win_amd64.whl", hash = "sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218"}, + {file = "numpy-1.26.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b"}, + {file = "numpy-1.26.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a"}, + {file = "numpy-1.26.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0"}, + {file = "numpy-1.26.4-cp312-cp312-win32.whl", hash = "sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110"}, + {file = "numpy-1.26.4-cp312-cp312-win_amd64.whl", hash = "sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c"}, + {file = "numpy-1.26.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764"}, + {file = "numpy-1.26.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd"}, + {file = "numpy-1.26.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c"}, + {file = "numpy-1.26.4-cp39-cp39-win32.whl", hash = "sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6"}, + {file = "numpy-1.26.4-cp39-cp39-win_amd64.whl", hash = "sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c"}, + {file = "numpy-1.26.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0"}, + {file = "numpy-1.26.4.tar.gz", hash = "sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010"}, +] + +[[package]] +name = "oauthlib" +version = "3.2.2" +description = "A generic, spec-compliant, thorough implementation of the OAuth request-signing logic" +optional = false +python-versions = ">=3.6" +files = [ + {file = "oauthlib-3.2.2-py3-none-any.whl", hash = "sha256:8139f29aac13e25d502680e9e19963e83f16838d48a0d71c287fe40e7067fbca"}, + {file = "oauthlib-3.2.2.tar.gz", hash = "sha256:9859c40929662bec5d64f34d01c99e093149682a3f38915dc0655d5a633dd918"}, +] + +[package.extras] +rsa = ["cryptography (>=3.0.0)"] +signals = ["blinker (>=1.4.0)"] +signedtoken = ["cryptography (>=3.0.0)", "pyjwt (>=2.0.0,<3)"] + +[[package]] +name = "openpyxl" +version = "3.1.5" +description = "A Python library to read/write Excel 2010 xlsx/xlsm files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2"}, + {file = "openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050"}, +] + +[package.dependencies] +et-xmlfile = "*" + +[[package]] +name = "packaging" +version = "24.2" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"}, + {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"}, +] + +[[package]] +name = "pandas" +version = "2.0.3" +description = "Powerful data structures for data analysis, time series, and statistics" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pandas-2.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c7c9f27a4185304c7caf96dc7d91bc60bc162221152de697c98eb0b2648dd8"}, + {file = "pandas-2.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f167beed68918d62bffb6ec64f2e1d8a7d297a038f86d4aed056b9493fca407f"}, + {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce0c6f76a0f1ba361551f3e6dceaff06bde7514a374aa43e33b588ec10420183"}, + {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba619e410a21d8c387a1ea6e8a0e49bb42216474436245718d7f2e88a2f8d7c0"}, + {file = "pandas-2.0.3-cp310-cp310-win32.whl", hash = "sha256:3ef285093b4fe5058eefd756100a367f27029913760773c8bf1d2d8bebe5d210"}, + {file = "pandas-2.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:9ee1a69328d5c36c98d8e74db06f4ad518a1840e8ccb94a4ba86920986bb617e"}, + {file = "pandas-2.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b084b91d8d66ab19f5bb3256cbd5ea661848338301940e17f4492b2ce0801fe8"}, + {file = "pandas-2.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37673e3bdf1551b95bf5d4ce372b37770f9529743d2498032439371fc7b7eb26"}, + {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9cb1e14fdb546396b7e1b923ffaeeac24e4cedd14266c3497216dd4448e4f2d"}, + {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d9cd88488cceb7635aebb84809d087468eb33551097d600c6dad13602029c2df"}, + {file = "pandas-2.0.3-cp311-cp311-win32.whl", hash = "sha256:694888a81198786f0e164ee3a581df7d505024fbb1f15202fc7db88a71d84ebd"}, + {file = "pandas-2.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6a21ab5c89dcbd57f78d0ae16630b090eec626360085a4148693def5452d8a6b"}, + {file = "pandas-2.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9e4da0d45e7f34c069fe4d522359df7d23badf83abc1d1cef398895822d11061"}, + {file = "pandas-2.0.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:32fca2ee1b0d93dd71d979726b12b61faa06aeb93cf77468776287f41ff8fdc5"}, + {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:258d3624b3ae734490e4d63c430256e716f488c4fcb7c8e9bde2d3aa46c29089"}, + {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eae3dc34fa1aa7772dd3fc60270d13ced7346fcbcfee017d3132ec625e23bb0"}, + {file = "pandas-2.0.3-cp38-cp38-win32.whl", hash = "sha256:f3421a7afb1a43f7e38e82e844e2bca9a6d793d66c1a7f9f0ff39a795bbc5e02"}, + {file = "pandas-2.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:69d7f3884c95da3a31ef82b7618af5710dba95bb885ffab339aad925c3e8ce78"}, + {file = "pandas-2.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5247fb1ba347c1261cbbf0fcfba4a3121fbb4029d95d9ef4dc45406620b25c8b"}, + {file = "pandas-2.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:81af086f4543c9d8bb128328b5d32e9986e0c84d3ee673a2ac6fb57fd14f755e"}, + {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1994c789bf12a7c5098277fb43836ce090f1073858c10f9220998ac74f37c69b"}, + {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ec591c48e29226bcbb316e0c1e9423622bc7a4eaf1ef7c3c9fa1a3981f89641"}, + {file = "pandas-2.0.3-cp39-cp39-win32.whl", hash = "sha256:04dbdbaf2e4d46ca8da896e1805bc04eb85caa9a82e259e8eed00254d5e0c682"}, + {file = "pandas-2.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:1168574b036cd8b93abc746171c9b4f1b83467438a5e45909fed645cf8692dbc"}, + {file = "pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c"}, +] + +[package.dependencies] +numpy = [ + {version = ">=1.20.3", markers = "python_version < \"3.10\""}, + {version = ">=1.21.0", markers = "python_version >= \"3.10\" and python_version < \"3.11\""}, + {version = ">=1.23.2", markers = "python_version >= \"3.11\""}, +] +python-dateutil = ">=2.8.2" +pytz = ">=2020.1" +tzdata = ">=2022.1" + +[package.extras] +all = ["PyQt5 (>=5.15.1)", "SQLAlchemy (>=1.4.16)", "beautifulsoup4 (>=4.9.3)", "bottleneck (>=1.3.2)", "brotlipy (>=0.7.0)", "fastparquet (>=0.6.3)", "fsspec (>=2021.07.0)", "gcsfs (>=2021.07.0)", "html5lib (>=1.1)", "hypothesis (>=6.34.2)", "jinja2 (>=3.0.0)", "lxml (>=4.6.3)", "matplotlib (>=3.6.1)", "numba (>=0.53.1)", "numexpr (>=2.7.3)", "odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pandas-gbq (>=0.15.0)", "psycopg2 (>=2.8.6)", "pyarrow (>=7.0.0)", "pymysql (>=1.0.2)", "pyreadstat (>=1.1.2)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)", "python-snappy (>=0.6.0)", "pyxlsb (>=1.0.8)", "qtpy (>=2.2.0)", "s3fs (>=2021.08.0)", "scipy (>=1.7.1)", "tables (>=3.6.1)", "tabulate (>=0.8.9)", "xarray (>=0.21.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)", "zstandard (>=0.15.2)"] +aws = ["s3fs (>=2021.08.0)"] +clipboard = ["PyQt5 (>=5.15.1)", "qtpy (>=2.2.0)"] +compression = ["brotlipy (>=0.7.0)", "python-snappy (>=0.6.0)", "zstandard (>=0.15.2)"] +computation = ["scipy (>=1.7.1)", "xarray (>=0.21.0)"] +excel = ["odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pyxlsb (>=1.0.8)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)"] +feather = ["pyarrow (>=7.0.0)"] +fss = ["fsspec (>=2021.07.0)"] +gcp = ["gcsfs (>=2021.07.0)", "pandas-gbq (>=0.15.0)"] +hdf5 = ["tables (>=3.6.1)"] +html = ["beautifulsoup4 (>=4.9.3)", "html5lib (>=1.1)", "lxml (>=4.6.3)"] +mysql = ["SQLAlchemy (>=1.4.16)", "pymysql (>=1.0.2)"] +output-formatting = ["jinja2 (>=3.0.0)", "tabulate (>=0.8.9)"] +parquet = ["pyarrow (>=7.0.0)"] +performance = ["bottleneck (>=1.3.2)", "numba (>=0.53.1)", "numexpr (>=2.7.1)"] +plot = ["matplotlib (>=3.6.1)"] +postgresql = ["SQLAlchemy (>=1.4.16)", "psycopg2 (>=2.8.6)"] +spss = ["pyreadstat (>=1.1.2)"] +sql-other = ["SQLAlchemy (>=1.4.16)"] +test = ["hypothesis (>=6.34.2)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)"] +xml = ["lxml (>=4.6.3)"] + +[[package]] +name = "pathspec" +version = "0.12.1" +description = "Utility library for gitignore style pattern matching of file paths." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"}, + {file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"}, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." +optional = false +python-versions = ">=3.8" +files = [ + {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"}, + {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"}, +] + +[package.extras] +docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.2)", "pytest-cov (>=5)", "pytest-mock (>=3.14)"] +type = ["mypy (>=1.11.2)"] + +[[package]] +name = "pluggy" +version = "1.5.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"}, + {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "pylint" +version = "3.2.7" +description = "python code static checker" +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "pylint-3.2.7-py3-none-any.whl", hash = "sha256:02f4aedeac91be69fb3b4bea997ce580a4ac68ce58b89eaefeaf06749df73f4b"}, + {file = "pylint-3.2.7.tar.gz", hash = "sha256:1b7a721b575eaeaa7d39db076b6e7743c993ea44f57979127c517c6c572c803e"}, +] + +[package.dependencies] +astroid = ">=3.2.4,<=3.3.0-dev0" +colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""} +dill = [ + {version = ">=0.2", markers = "python_version < \"3.11\""}, + {version = ">=0.3.7", markers = "python_version >= \"3.12\""}, + {version = ">=0.3.6", markers = "python_version >= \"3.11\" and python_version < \"3.12\""}, +] +isort = ">=4.2.5,<5.13.0 || >5.13.0,<6" +mccabe = ">=0.6,<0.8" +platformdirs = ">=2.2.0" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +tomlkit = ">=0.10.1" +typing-extensions = {version = ">=3.10.0", markers = "python_version < \"3.10\""} + +[package.extras] +spelling = ["pyenchant (>=3.2,<4.0)"] +testutils = ["gitpython (>3)"] + +[[package]] +name = "pytest" +version = "7.4.4" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-7.4.4-py3-none-any.whl", hash = "sha256:b090cdf5ed60bf4c45261be03239c2c1c22df034fbffe691abe93cd80cea01d8"}, + {file = "pytest-7.4.4.tar.gz", hash = "sha256:2cf0005922c6ace4a3e2ec8b4080eb0d9753fdc93107415332f50ce9e7994280"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=0.12,<2.0" +tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""} + +[package.extras] +testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] + +[[package]] +name = "pytest-dotenv" +version = "0.5.2" +description = "A py.test plugin that parses environment files before running tests" +optional = false +python-versions = "*" +files = [ + {file = "pytest-dotenv-0.5.2.tar.gz", hash = "sha256:2dc6c3ac6d8764c71c6d2804e902d0ff810fa19692e95fe138aefc9b1aa73732"}, + {file = "pytest_dotenv-0.5.2-py3-none-any.whl", hash = "sha256:40a2cece120a213898afaa5407673f6bd924b1fa7eafce6bda0e8abffe2f710f"}, +] + +[package.dependencies] +pytest = ">=5.0.0" +python-dotenv = ">=0.9.1" + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +description = "Extensions to the standard Python datetime module" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"}, + {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"}, +] + +[package.dependencies] +six = ">=1.5" + +[[package]] +name = "python-dotenv" +version = "1.0.1" +description = "Read key-value pairs from a .env file and set them as environment variables" +optional = false +python-versions = ">=3.8" +files = [ + {file = "python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca"}, + {file = "python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"}, +] + +[package.extras] +cli = ["click (>=5.0)"] + +[[package]] +name = "pytz" +version = "2024.2" +description = "World timezone definitions, modern and historical" +optional = false +python-versions = "*" +files = [ + {file = "pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725"}, + {file = "pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a"}, +] + +[[package]] +name = "requests" +version = "2.32.3" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.8" +files = [ + {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"}, + {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "sqlalchemy" +version = "1.4.54" +description = "Database Abstraction Library" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "SQLAlchemy-1.4.54-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:af00236fe21c4d4f4c227b6ccc19b44c594160cc3ff28d104cdce85855369277"}, + {file = "SQLAlchemy-1.4.54-cp310-cp310-manylinux1_x86_64.manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_5_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1183599e25fa38a1a322294b949da02b4f0da13dbc2688ef9dbe746df573f8a6"}, + {file = "SQLAlchemy-1.4.54-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1990d5a6a5dc358a0894c8ca02043fb9a5ad9538422001fb2826e91c50f1d539"}, + {file = "SQLAlchemy-1.4.54-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:14b3f4783275339170984cadda66e3ec011cce87b405968dc8d51cf0f9997b0d"}, + {file = "SQLAlchemy-1.4.54-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b24364150738ce488333b3fb48bfa14c189a66de41cd632796fbcacb26b4585"}, + {file = "SQLAlchemy-1.4.54-cp310-cp310-win32.whl", hash = "sha256:a8a72259a1652f192c68377be7011eac3c463e9892ef2948828c7d58e4829988"}, + {file = "SQLAlchemy-1.4.54-cp310-cp310-win_amd64.whl", hash = "sha256:b67589f7955924865344e6eacfdcf70675e64f36800a576aa5e961f0008cde2a"}, + {file = "SQLAlchemy-1.4.54-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b05e0626ec1c391432eabb47a8abd3bf199fb74bfde7cc44a26d2b1b352c2c6e"}, + {file = "SQLAlchemy-1.4.54-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:13e91d6892b5fcb94a36ba061fb7a1f03d0185ed9d8a77c84ba389e5bb05e936"}, + {file = "SQLAlchemy-1.4.54-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb59a11689ff3c58e7652260127f9e34f7f45478a2f3ef831ab6db7bcd72108f"}, + {file = "SQLAlchemy-1.4.54-cp311-cp311-win32.whl", hash = "sha256:1390ca2d301a2708fd4425c6d75528d22f26b8f5cbc9faba1ddca136671432bc"}, + {file = "SQLAlchemy-1.4.54-cp311-cp311-win_amd64.whl", hash = "sha256:2b37931eac4b837c45e2522066bda221ac6d80e78922fb77c75eb12e4dbcdee5"}, + {file = "SQLAlchemy-1.4.54-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:3f01c2629a7d6b30d8afe0326b8c649b74825a0e1ebdcb01e8ffd1c920deb07d"}, + {file = "SQLAlchemy-1.4.54-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c24dd161c06992ed16c5e528a75878edbaeced5660c3db88c820f1f0d3fe1f4"}, + {file = "SQLAlchemy-1.4.54-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5e0d47d619c739bdc636bbe007da4519fc953393304a5943e0b5aec96c9877c"}, + {file = "SQLAlchemy-1.4.54-cp312-cp312-win32.whl", hash = "sha256:12bc0141b245918b80d9d17eca94663dbd3f5266ac77a0be60750f36102bbb0f"}, + {file = "SQLAlchemy-1.4.54-cp312-cp312-win_amd64.whl", hash = "sha256:f941aaf15f47f316123e1933f9ea91a6efda73a161a6ab6046d1cde37be62c88"}, + {file = "SQLAlchemy-1.4.54-cp36-cp36m-macosx_10_14_x86_64.whl", hash = "sha256:a41611835010ed4ea4c7aed1da5b58aac78ee7e70932a91ed2705a7b38e40f52"}, + {file = "SQLAlchemy-1.4.54-cp36-cp36m-manylinux1_x86_64.manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_5_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e8c1b9ecaf9f2590337d5622189aeb2f0dbc54ba0232fa0856cf390957584a9"}, + {file = "SQLAlchemy-1.4.54-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0de620f978ca273ce027769dc8db7e6ee72631796187adc8471b3c76091b809e"}, + {file = "SQLAlchemy-1.4.54-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c5a2530400a6e7e68fd1552a55515de6a4559122e495f73554a51cedafc11669"}, + {file = "SQLAlchemy-1.4.54-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0cf7076c8578b3de4e43a046cc7a1af8466e1c3f5e64167189fe8958a4f9c02"}, + {file = "SQLAlchemy-1.4.54-cp37-cp37m-macosx_11_0_x86_64.whl", hash = "sha256:f1e1b92ee4ee9ffc68624ace218b89ca5ca667607ccee4541a90cc44999b9aea"}, + {file = "SQLAlchemy-1.4.54-cp37-cp37m-manylinux1_x86_64.manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_5_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41cffc63c7c83dfc30c4cab5b4308ba74440a9633c4509c51a0c52431fb0f8ab"}, + {file = "SQLAlchemy-1.4.54-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5933c45d11cbd9694b1540aa9076816cc7406964c7b16a380fd84d3a5fe3241"}, + {file = "SQLAlchemy-1.4.54-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:cafe0ba3a96d0845121433cffa2b9232844a2609fce694fcc02f3f31214ece28"}, + {file = "SQLAlchemy-1.4.54-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a19f816f4702d7b1951d7576026c7124b9bfb64a9543e571774cf517b7a50b29"}, + {file = "SQLAlchemy-1.4.54-cp37-cp37m-win32.whl", hash = "sha256:76c2ba7b5a09863d0a8166fbc753af96d561818c572dbaf697c52095938e7be4"}, + {file = "SQLAlchemy-1.4.54-cp37-cp37m-win_amd64.whl", hash = "sha256:a86b0e4be775902a5496af4fb1b60d8a2a457d78f531458d294360b8637bb014"}, + {file = "SQLAlchemy-1.4.54-cp38-cp38-macosx_12_0_x86_64.whl", hash = "sha256:a49730afb716f3f675755afec109895cab95bc9875db7ffe2e42c1b1c6279482"}, + {file = "SQLAlchemy-1.4.54-cp38-cp38-manylinux1_x86_64.manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_5_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26e78444bc77d089e62874dc74df05a5c71f01ac598010a327881a48408d0064"}, + {file = "SQLAlchemy-1.4.54-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:02d2ecb9508f16ab9c5af466dfe5a88e26adf2e1a8d1c56eb616396ccae2c186"}, + {file = "SQLAlchemy-1.4.54-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:394b0135900b62dbf63e4809cdc8ac923182af2816d06ea61cd6763943c2cc05"}, + {file = "SQLAlchemy-1.4.54-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ed3576675c187e3baa80b02c4c9d0edfab78eff4e89dd9da736b921333a2432"}, + {file = "SQLAlchemy-1.4.54-cp38-cp38-win32.whl", hash = "sha256:fc9ffd9a38e21fad3e8c5a88926d57f94a32546e937e0be46142b2702003eba7"}, + {file = "SQLAlchemy-1.4.54-cp38-cp38-win_amd64.whl", hash = "sha256:a01bc25eb7a5688656c8770f931d5cb4a44c7de1b3cec69b84cc9745d1e4cc10"}, + {file = "SQLAlchemy-1.4.54-cp39-cp39-macosx_12_0_x86_64.whl", hash = "sha256:0b76bbb1cbae618d10679be8966f6d66c94f301cfc15cb49e2f2382563fb6efb"}, + {file = "SQLAlchemy-1.4.54-cp39-cp39-manylinux1_x86_64.manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_5_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdb2886c0be2c6c54d0651d5a61c29ef347e8eec81fd83afebbf7b59b80b7393"}, + {file = "SQLAlchemy-1.4.54-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:954816850777ac234a4e32b8c88ac1f7847088a6e90cfb8f0e127a1bf3feddff"}, + {file = "SQLAlchemy-1.4.54-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:1d83cd1cc03c22d922ec94d0d5f7b7c96b1332f5e122e81b1a61fb22da77879a"}, + {file = "SQLAlchemy-1.4.54-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1576fba3616f79496e2f067262200dbf4aab1bb727cd7e4e006076686413c80c"}, + {file = "SQLAlchemy-1.4.54-cp39-cp39-win32.whl", hash = "sha256:3112de9e11ff1957148c6de1df2bc5cc1440ee36783412e5eedc6f53638a577d"}, + {file = "SQLAlchemy-1.4.54-cp39-cp39-win_amd64.whl", hash = "sha256:6da60fb24577f989535b8fc8b2ddc4212204aaf02e53c4c7ac94ac364150ed08"}, + {file = "sqlalchemy-1.4.54.tar.gz", hash = "sha256:4470fbed088c35dc20b78a39aaf4ae54fe81790c783b3264872a0224f437c31a"}, +] + +[package.dependencies] +greenlet = {version = "!=0.4.17", markers = "python_version >= \"3\" and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\")"} + +[package.extras] +aiomysql = ["aiomysql (>=0.2.0)", "greenlet (!=0.4.17)"] +aiosqlite = ["aiosqlite", "greenlet (!=0.4.17)", "typing_extensions (!=3.10.0.1)"] +asyncio = ["greenlet (!=0.4.17)"] +asyncmy = ["asyncmy (>=0.2.3,!=0.2.4)", "greenlet (!=0.4.17)"] +mariadb-connector = ["mariadb (>=1.0.1,!=1.1.2)", "mariadb (>=1.0.1,!=1.1.2)"] +mssql = ["pyodbc"] +mssql-pymssql = ["pymssql", "pymssql"] +mssql-pyodbc = ["pyodbc", "pyodbc"] +mypy = ["mypy (>=0.910)", "sqlalchemy2-stubs"] +mysql = ["mysqlclient (>=1.4.0)", "mysqlclient (>=1.4.0,<2)"] +mysql-connector = ["mysql-connector-python", "mysql-connector-python"] +oracle = ["cx_oracle (>=7)", "cx_oracle (>=7,<8)"] +postgresql = ["psycopg2 (>=2.7)"] +postgresql-asyncpg = ["asyncpg", "asyncpg", "greenlet (!=0.4.17)", "greenlet (!=0.4.17)"] +postgresql-pg8000 = ["pg8000 (>=1.16.6,!=1.29.0)", "pg8000 (>=1.16.6,!=1.29.0)"] +postgresql-psycopg2binary = ["psycopg2-binary"] +postgresql-psycopg2cffi = ["psycopg2cffi"] +pymysql = ["pymysql", "pymysql (<1)"] +sqlcipher = ["sqlcipher3_binary"] + +[[package]] +name = "thrift" +version = "0.20.0" +description = "Python bindings for the Apache Thrift RPC system" +optional = false +python-versions = "*" +files = [ + {file = "thrift-0.20.0.tar.gz", hash = "sha256:4dd662eadf6b8aebe8a41729527bd69adf6ceaa2a8681cbef64d1273b3e8feba"}, +] + +[package.dependencies] +six = ">=1.7.2" + +[package.extras] +all = ["tornado (>=4.0)", "twisted"] +tornado = ["tornado (>=4.0)"] +twisted = ["twisted"] + +[[package]] +name = "tomli" +version = "2.1.0" +description = "A lil' TOML parser" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tomli-2.1.0-py3-none-any.whl", hash = "sha256:a5c57c3d1c56f5ccdf89f6523458f60ef716e210fc47c4cfb188c5ba473e0391"}, + {file = "tomli-2.1.0.tar.gz", hash = "sha256:3f646cae2aec94e17d04973e4249548320197cfabdf130015d023de4b74d8ab8"}, +] + +[[package]] +name = "tomlkit" +version = "0.13.2" +description = "Style preserving TOML library" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tomlkit-0.13.2-py3-none-any.whl", hash = "sha256:7a974427f6e119197f670fbbbeae7bef749a6c14e793db934baefc1b5f03efde"}, + {file = "tomlkit-0.13.2.tar.gz", hash = "sha256:fff5fe59a87295b278abd31bec92c15d9bc4a06885ab12bcea52c71119392e79"}, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +description = "Backported and Experimental Type Hints for Python 3.8+" +optional = false +python-versions = ">=3.8" +files = [ + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, +] + +[[package]] +name = "tzdata" +version = "2024.2" +description = "Provider of IANA time zone data" +optional = false +python-versions = ">=2" +files = [ + {file = "tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd"}, + {file = "tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc"}, +] + +[[package]] +name = "urllib3" +version = "2.2.3" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.8" +files = [ + {file = "urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac"}, + {file = "urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + +[metadata] +lock-version = "2.0" +python-versions = "^3.8.0" +content-hash = "01d4b81b143fa9b057074091b596c8979020d8a6b08770b1054f6fde39e18955" diff --git a/pyproject.toml b/pyproject.toml index 13d61fc..b2a296a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "databricks-sqlalchemy" -version = "1.0.2" +version = "1.0.3" description = "Databricks SQLAlchemy plugin for Python" authors = ["Databricks "] license = "Apache-2.0" @@ -10,6 +10,7 @@ include = ["CHANGELOG.md"] [tool.poetry.dependencies] python = "^3.8.0" +databricks_sql_connector = { version = "==4.0.0.b4"} sqlalchemy = { version = "^1.3.24" } [tool.poetry.dev-dependencies] From 7475f28183213f240d9c9cb337e021e33f6de25a Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Wed, 13 Nov 2024 13:48:40 +0530 Subject: [PATCH 05/11] Changelog updates --- CHANGELOG.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2660d32..8a1b34b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,6 @@ # Release History -# 1.0.1 +# 1.0.3 -- This is databricks-sqlalchemy plugin based on sqlalchemy v1 and has all the databricks-sql-python v2.9.6 needed sqlalchemy features +- All the SQLAlchemy features from `databricks-sql-connector>=4.0.0` have been moved to this `databricks-sqlalchemy` library +- Support for SQLAlchemy v1 dialect is provided \ No newline at end of file From 1019a5ce95b955a15a807163b3f922c660fd375b Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Thu, 14 Nov 2024 14:02:17 +0530 Subject: [PATCH 06/11] Bumped up to 1.0.4 and added pyarrow in pyproject.toml --- CHANGELOG.md | 2 +- pyproject.toml | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8a1b34b..eaec05d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Release History -# 1.0.3 +# 1.0.4 - All the SQLAlchemy features from `databricks-sql-connector>=4.0.0` have been moved to this `databricks-sqlalchemy` library - Support for SQLAlchemy v1 dialect is provided \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index b2a296a..ab6ec7a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "databricks-sqlalchemy" -version = "1.0.3" +version = "1.0.4" description = "Databricks SQLAlchemy plugin for Python" authors = ["Databricks "] license = "Apache-2.0" @@ -11,6 +11,7 @@ include = ["CHANGELOG.md"] [tool.poetry.dependencies] python = "^3.8.0" databricks_sql_connector = { version = "==4.0.0.b4"} +pyarrow = { version = ">=14.0.1,<17"} sqlalchemy = { version = "^1.3.24" } [tool.poetry.dev-dependencies] From c4cb345d316586d9fc90122220565c80ba14192d Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Fri, 15 Nov 2024 11:36:34 +0530 Subject: [PATCH 07/11] Added pull request_template and code-quality-checks --- .github/.github/pull_request_template.md | 23 +++++ .github/workflows/code-quality-checks.yml | 114 ++++++++++++++++++++++ poetry.lock | 50 +++++++++- 3 files changed, 186 insertions(+), 1 deletion(-) create mode 100644 .github/.github/pull_request_template.md create mode 100644 .github/workflows/code-quality-checks.yml diff --git a/.github/.github/pull_request_template.md b/.github/.github/pull_request_template.md new file mode 100644 index 0000000..62c0286 --- /dev/null +++ b/.github/.github/pull_request_template.md @@ -0,0 +1,23 @@ + + + +## What type of PR is this? + + +- [ ] Refactor +- [ ] Feature +- [ ] Bug Fix +- [ ] Other + +## Description + +## How is this tested? + +- [ ] Unit tests +- [ ] E2E Tests +- [ ] Manually +- [ ] N/A + + + +## Related Tickets & Documents diff --git a/.github/workflows/code-quality-checks.yml b/.github/workflows/code-quality-checks.yml new file mode 100644 index 0000000..468343d --- /dev/null +++ b/.github/workflows/code-quality-checks.yml @@ -0,0 +1,114 @@ +name: Code Quality Checks +on: + push: + branches: + - v1/main + pull_request: + branches: + - v1/main +jobs: + check-linting: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: [3.8, 3.9, "3.10"] + steps: + #---------------------------------------------- + # check-out repo and set-up python + #---------------------------------------------- + - name: Check out repository + uses: actions/checkout@v2 + - name: Set up python ${{ matrix.python-version }} + id: setup-python + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + #---------------------------------------------- + # ----- install & configure poetry ----- + #---------------------------------------------- + - name: Install Poetry + uses: snok/install-poetry@v1 + with: + virtualenvs-create: true + virtualenvs-in-project: true + installer-parallel: true + + #---------------------------------------------- + # load cached venv if cache exists + #---------------------------------------------- + - name: Load cached venv + id: cached-poetry-dependencies + uses: actions/cache@v2 + with: + path: .venv + key: venv-${{ runner.os }}-${{ steps.setup-python.outputs.python-version }}-${{ github.event.repository.name }}-${{ hashFiles('**/poetry.lock') }} + #---------------------------------------------- + # install dependencies if cache does not exist + #---------------------------------------------- + - name: Install dependencies + if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true' + run: poetry install --no-interaction --no-root + #---------------------------------------------- + # install your root project, if required + #---------------------------------------------- + - name: Install library + run: poetry install --no-interaction + #---------------------------------------------- + # black the code + #---------------------------------------------- + - name: Black + run: poetry run black --check src + + check-types: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: [3.8, 3.9, "3.10"] + steps: + #---------------------------------------------- + # check-out repo and set-up python + #---------------------------------------------- + - name: Check out repository + uses: actions/checkout@v2 + - name: Set up python ${{ matrix.python-version }} + id: setup-python + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + #---------------------------------------------- + # ----- install & configure poetry ----- + #---------------------------------------------- + - name: Install Poetry + uses: snok/install-poetry@v1 + with: + virtualenvs-create: true + virtualenvs-in-project: true + installer-parallel: true + + #---------------------------------------------- + # load cached venv if cache exists + #---------------------------------------------- + - name: Load cached venv + id: cached-poetry-dependencies + uses: actions/cache@v2 + with: + path: .venv + key: venv-${{ runner.os }}-${{ steps.setup-python.outputs.python-version }}-${{ github.event.repository.name }}-${{ hashFiles('**/poetry.lock') }} + #---------------------------------------------- + # install dependencies if cache does not exist + #---------------------------------------------- + - name: Install dependencies + if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true' + run: poetry install --no-interaction --no-root + #---------------------------------------------- + # install your root project, if required + #---------------------------------------------- + - name: Install library + run: poetry install --no-interaction + #---------------------------------------------- + # mypy the code + #---------------------------------------------- + - name: Mypy + run: | + mkdir .mypy_cache # Workaround for bad error message "error: --install-types failed (no mypy cache directory)"; see https://github.com/python/mypy/issues/10768#issuecomment-2178450153 + poetry run mypy --install-types --non-interactive src diff --git a/poetry.lock b/poetry.lock index 048bd04..2c5b735 100644 --- a/poetry.lock +++ b/poetry.lock @@ -748,6 +748,54 @@ files = [ dev = ["pre-commit", "tox"] testing = ["pytest", "pytest-benchmark"] +[[package]] +name = "pyarrow" +version = "16.1.0" +description = "Python library for Apache Arrow" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pyarrow-16.1.0-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:17e23b9a65a70cc733d8b738baa6ad3722298fa0c81d88f63ff94bf25eaa77b9"}, + {file = "pyarrow-16.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4740cc41e2ba5d641071d0ab5e9ef9b5e6e8c7611351a5cb7c1d175eaf43674a"}, + {file = "pyarrow-16.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:98100e0268d04e0eec47b73f20b39c45b4006f3c4233719c3848aa27a03c1aef"}, + {file = "pyarrow-16.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f68f409e7b283c085f2da014f9ef81e885d90dcd733bd648cfba3ef265961848"}, + {file = "pyarrow-16.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:a8914cd176f448e09746037b0c6b3a9d7688cef451ec5735094055116857580c"}, + {file = "pyarrow-16.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:48be160782c0556156d91adbdd5a4a7e719f8d407cb46ae3bb4eaee09b3111bd"}, + {file = "pyarrow-16.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:9cf389d444b0f41d9fe1444b70650fea31e9d52cfcb5f818b7888b91b586efff"}, + {file = "pyarrow-16.1.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:d0ebea336b535b37eee9eee31761813086d33ed06de9ab6fc6aaa0bace7b250c"}, + {file = "pyarrow-16.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2e73cfc4a99e796727919c5541c65bb88b973377501e39b9842ea71401ca6c1c"}, + {file = "pyarrow-16.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf9251264247ecfe93e5f5a0cd43b8ae834f1e61d1abca22da55b20c788417f6"}, + {file = "pyarrow-16.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddf5aace92d520d3d2a20031d8b0ec27b4395cab9f74e07cc95edf42a5cc0147"}, + {file = "pyarrow-16.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:25233642583bf658f629eb230b9bb79d9af4d9f9229890b3c878699c82f7d11e"}, + {file = "pyarrow-16.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a33a64576fddfbec0a44112eaf844c20853647ca833e9a647bfae0582b2ff94b"}, + {file = "pyarrow-16.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:185d121b50836379fe012753cf15c4ba9638bda9645183ab36246923875f8d1b"}, + {file = "pyarrow-16.1.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:2e51ca1d6ed7f2e9d5c3c83decf27b0d17bb207a7dea986e8dc3e24f80ff7d6f"}, + {file = "pyarrow-16.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:06ebccb6f8cb7357de85f60d5da50e83507954af617d7b05f48af1621d331c9a"}, + {file = "pyarrow-16.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b04707f1979815f5e49824ce52d1dceb46e2f12909a48a6a753fe7cafbc44a0c"}, + {file = "pyarrow-16.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d32000693deff8dc5df444b032b5985a48592c0697cb6e3071a5d59888714e2"}, + {file = "pyarrow-16.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:8785bb10d5d6fd5e15d718ee1d1f914fe768bf8b4d1e5e9bf253de8a26cb1628"}, + {file = "pyarrow-16.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e1369af39587b794873b8a307cc6623a3b1194e69399af0efd05bb202195a5a7"}, + {file = "pyarrow-16.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:febde33305f1498f6df85e8020bca496d0e9ebf2093bab9e0f65e2b4ae2b3444"}, + {file = "pyarrow-16.1.0-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:b5f5705ab977947a43ac83b52ade3b881eb6e95fcc02d76f501d549a210ba77f"}, + {file = "pyarrow-16.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:0d27bf89dfc2576f6206e9cd6cf7a107c9c06dc13d53bbc25b0bd4556f19cf5f"}, + {file = "pyarrow-16.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d07de3ee730647a600037bc1d7b7994067ed64d0eba797ac74b2bc77384f4c2"}, + {file = "pyarrow-16.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fbef391b63f708e103df99fbaa3acf9f671d77a183a07546ba2f2c297b361e83"}, + {file = "pyarrow-16.1.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:19741c4dbbbc986d38856ee7ddfdd6a00fc3b0fc2d928795b95410d38bb97d15"}, + {file = "pyarrow-16.1.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:f2c5fb249caa17b94e2b9278b36a05ce03d3180e6da0c4c3b3ce5b2788f30eed"}, + {file = "pyarrow-16.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:e6b6d3cd35fbb93b70ade1336022cc1147b95ec6af7d36906ca7fe432eb09710"}, + {file = "pyarrow-16.1.0-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:18da9b76a36a954665ccca8aa6bd9f46c1145f79c0bb8f4f244f5f8e799bca55"}, + {file = "pyarrow-16.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:99f7549779b6e434467d2aa43ab2b7224dd9e41bdde486020bae198978c9e05e"}, + {file = "pyarrow-16.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f07fdffe4fd5b15f5ec15c8b64584868d063bc22b86b46c9695624ca3505b7b4"}, + {file = "pyarrow-16.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddfe389a08ea374972bd4065d5f25d14e36b43ebc22fc75f7b951f24378bf0b5"}, + {file = "pyarrow-16.1.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:3b20bd67c94b3a2ea0a749d2a5712fc845a69cb5d52e78e6449bbd295611f3aa"}, + {file = "pyarrow-16.1.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:ba8ac20693c0bb0bf4b238751d4409e62852004a8cf031c73b0e0962b03e45e3"}, + {file = "pyarrow-16.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:31a1851751433d89a986616015841977e0a188662fcffd1a5677453f1df2de0a"}, + {file = "pyarrow-16.1.0.tar.gz", hash = "sha256:15fbb22ea96d11f0b5768504a3f961edab25eaf4197c341720c4a387f6c60315"}, +] + +[package.dependencies] +numpy = ">=1.16.6" + [[package]] name = "pylint" version = "3.2.7" @@ -1045,4 +1093,4 @@ zstd = ["zstandard (>=0.18.0)"] [metadata] lock-version = "2.0" python-versions = "^3.8.0" -content-hash = "01d4b81b143fa9b057074091b596c8979020d8a6b08770b1054f6fde39e18955" +content-hash = "d576c2a936ccdfec116c3f557a50afeeffa908332a5463548e2d331ee0c2974f" From f6c2940e602db84933879842f65fc998515def79 Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Mon, 18 Nov 2024 10:11:39 +0530 Subject: [PATCH 08/11] Setting up github actions for SQLAlachemy v1 (#8) * Modified example.py * workflow dispatch * Added github workflows * Updated publishing to test pypi * Check * Check * Check * Check * Check * Check * Check * Check * Fixed the github actions not working issue * Ignore imports in mypy * Minor fix * Minor fix --- .github/workflows/code-quality-checks.yml | 1 + .github/workflows/dco-check.yml | 25 +++++++++ .github/workflows/publish-test.yml | 62 +++++++++++++++++++++ .github/workflows/publish.yml | 65 +++++++++++++++++++++++ pyproject.toml | 2 + src/databricks/__init__.py | 0 6 files changed, 155 insertions(+) create mode 100644 .github/workflows/dco-check.yml create mode 100644 .github/workflows/publish-test.yml create mode 100644 .github/workflows/publish.yml create mode 100644 src/databricks/__init__.py diff --git a/.github/workflows/code-quality-checks.yml b/.github/workflows/code-quality-checks.yml index 468343d..2f23e0d 100644 --- a/.github/workflows/code-quality-checks.yml +++ b/.github/workflows/code-quality-checks.yml @@ -6,6 +6,7 @@ on: pull_request: branches: - v1/main + workflow_dispatch: jobs: check-linting: runs-on: ubuntu-latest diff --git a/.github/workflows/dco-check.yml b/.github/workflows/dco-check.yml new file mode 100644 index 0000000..dbe9669 --- /dev/null +++ b/.github/workflows/dco-check.yml @@ -0,0 +1,25 @@ +name: DCO Check + +on: [pull_request] + +jobs: + check: + runs-on: ubuntu-latest + steps: + - name: Check for DCO + id: dco-check + uses: tisonkun/actions-dco@v1.1 + - name: Comment about DCO status + uses: actions/github-script@v6 + if: ${{ failure() }} + with: + script: | + github.rest.issues.createComment({ + issue_number: context.issue.number, + owner: context.repo.owner, + repo: context.repo.repo, + body: `Thanks for your contribution! To satisfy the DCO policy in our \ + [contributing guide](https://github.com/databricks/databricks-sqlalchemy/blob/main/CONTRIBUTING.md) \ + every commit message must include a sign-off message. One or more of your commits is missing this message. \ + You can reword previous commit messages with an interactive rebase (\`git rebase -i main\`).` + }) diff --git a/.github/workflows/publish-test.yml b/.github/workflows/publish-test.yml new file mode 100644 index 0000000..520cfbb --- /dev/null +++ b/.github/workflows/publish-test.yml @@ -0,0 +1,62 @@ +name: Publish to PyPI [Test] +on: [push] +jobs: + test-pypi: + name: Create patch version number and push to test-pypi + runs-on: ubuntu-latest + steps: + #---------------------------------------------- + # check-out repo and set-up python + #---------------------------------------------- + - name: Check out repository + uses: actions/checkout@v2 + - name: Set up python + id: setup-python + uses: actions/setup-python@v2 + with: + python-version: 3.9 + #---------------------------------------------- + # ----- install & configure poetry ----- + #---------------------------------------------- + - name: Install Poetry + uses: snok/install-poetry@v1 + with: + virtualenvs-create: true + virtualenvs-in-project: true + installer-parallel: true + #---------------------------------------------- + # load cached venv if cache exists + #---------------------------------------------- + - name: Load cached venv + id: cached-poetry-dependencies + uses: actions/cache@v2 + with: + path: .venv + key: venv-${{ runner.os }}-${{ steps.setup-python.outputs.python-version }}-${{ github.event.repository.name }}-${{ hashFiles('**/poetry.lock') }} + #---------------------------------------------- + # install dependencies if cache does not exist + #---------------------------------------------- + - name: Install dependencies + if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true' + run: poetry install --no-interaction --no-root + #---------------------------------------------- + # Get the current version and increment it (test-pypi requires a unique version number) + #---------------------------------------------- + - name: Get next version + uses: reecetech/version-increment@2022.2.4 + id: version + with: + scheme: semver + increment: patch + #---------------------------------------------- + # Tell poetry to update the version number + #---------------------------------------------- + - name: Update pyproject.toml + run: poetry version ${{ steps.version.outputs.major-version }}.${{ steps.version.outputs.minor-version }}.dev$(date +%s) + + - name: Build and publish to pypi + uses: JRubics/poetry-publish@v1.10 + with: + pypi_token: ${{ secrets.SQLALCHEMY_TEST_PYPI_TOKEN }} + repository_name: "testpypi" + repository_url: "https://test.pypi.org/legacy/" diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..970229c --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,65 @@ +name: Publish to PyPI [Production] +on: + release: + types: [published] +jobs: + publish: + name: Publish + runs-on: ubuntu-latest + if: github.ref == 'refs/heads/v1/main' + steps: + #---------------------------------------------- + # check-out repo and set-up python + #---------------------------------------------- + - name: Check out repository + uses: actions/checkout@v2 + - name: Set up python + id: setup-python + uses: actions/setup-python@v2 + with: + python-version: 3.9 + #---------------------------------------------- + # ----- install & configure poetry ----- + #---------------------------------------------- + - name: Install Poetry + uses: snok/install-poetry@v1 + with: + virtualenvs-create: true + virtualenvs-in-project: true + installer-parallel: true + #---------------------------------------------- + # load cached venv if cache exists + #---------------------------------------------- + - name: Load cached venv + id: cached-poetry-dependencies + uses: actions/cache@v2 + with: + path: .venv + key: venv-${{ runner.os }}-${{ steps.setup-python.outputs.python-version }}-${{ github.event.repository.name }}-${{ hashFiles('**/poetry.lock') }} + #---------------------------------------------- + # install dependencies if cache does not exist + #---------------------------------------------- + - name: Install dependencies + if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true' + run: poetry install --no-interaction --no-root + #------------------------------------------------------------------------------------------------ + # Here we use version-increment to fetch the latest tagged version (we won't increment it though) + #------------------------------------------------------------------------------------------------ + - name: Get next version + uses: reecetech/version-increment@2022.2.4 + id: version + with: + scheme: semver + increment: patch + #----------------------------------------------------------------------------- + # Tell poetry to use the `current-version` that was found by the previous step + #----------------------------------------------------------------------------- + - name: Update pyproject.toml + run: poetry version ${{ steps.version.outputs.current-version }} + #---------------------------------------------- + # Attempt push to test-pypi + #---------------------------------------------- + - name: Build and publish to pypi + uses: JRubics/poetry-publish@v1.10 + with: + pypi_token: ${{ secrets.SQLALCHEMY_PROD_PYPI_TOKEN }} diff --git a/pyproject.toml b/pyproject.toml index ab6ec7a..33a3a90 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,3 +35,5 @@ build-backend = "poetry.core.masonry.api" [tool.black] exclude = '/(\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|\.svn|_build|buck-out|build|dist|thrift_api)/' +[tool.mypy] +ignore_missing_imports = true diff --git a/src/databricks/__init__.py b/src/databricks/__init__.py new file mode 100644 index 0000000..e69de29 From 1ed488e4e47507ec64beb868e8c8d9ded7bfbe19 Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Tue, 3 Dec 2024 11:48:39 +0530 Subject: [PATCH 09/11] Added code owners --- .github/CODEOWNERS | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 .github/CODEOWNERS diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..acf4f8a --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,5 @@ +# These owners will be the default owners for everything in +# the repo. Unless a later match takes precedence, these +# users will be requested for review when someone opens a +# pull request. +* @yunbodeng-db @jackyhu-db @benc-db @jprakash-db @gopalldb From 81ce7553c1d9864dae2e0dd68f43da4ee120bb53 Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Tue, 28 Jan 2025 05:29:00 +0530 Subject: [PATCH 10/11] Updated support for >=4.0.0 connector (#15) --- .github/workflows/code-quality-checks.yml | 4 +- poetry.lock | 349 ++++++++++++---------- pyproject.toml | 2 +- 3 files changed, 189 insertions(+), 166 deletions(-) diff --git a/.github/workflows/code-quality-checks.yml b/.github/workflows/code-quality-checks.yml index 2f23e0d..131dc40 100644 --- a/.github/workflows/code-quality-checks.yml +++ b/.github/workflows/code-quality-checks.yml @@ -12,7 +12,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.8, 3.9, "3.10"] + python-version: [3.9, "3.10", "3.11", "3.12"] steps: #---------------------------------------------- # check-out repo and set-up python @@ -64,7 +64,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.8, 3.9, "3.10"] + python-version: [3.9, "3.10", "3.11", "3.12"] steps: #---------------------------------------------- # check-out repo and set-up python diff --git a/poetry.lock b/poetry.lock index 2c5b735..318d4c4 100644 --- a/poetry.lock +++ b/poetry.lock @@ -51,138 +51,125 @@ uvloop = ["uvloop (>=0.15.2)"] [[package]] name = "certifi" -version = "2024.8.30" +version = "2024.12.14" description = "Python package for providing Mozilla's CA Bundle." optional = false python-versions = ">=3.6" files = [ - {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, - {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, + {file = "certifi-2024.12.14-py3-none-any.whl", hash = "sha256:1275f7a45be9464efc1173084eaa30f866fe2e47d389406136d332ed4967ec56"}, + {file = "certifi-2024.12.14.tar.gz", hash = "sha256:b650d30f370c2b724812bee08008be0c4163b163ddaec3f2546c1caf65f191db"}, ] [[package]] name = "charset-normalizer" -version = "3.4.0" +version = "3.4.1" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = false -python-versions = ">=3.7.0" +python-versions = ">=3.7" files = [ - {file = "charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4f9fc98dad6c2eaa32fc3af1417d95b5e3d08aff968df0cd320066def971f9a6"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0de7b687289d3c1b3e8660d0741874abe7888100efe14bd0f9fd7141bcbda92b"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ed2e36c3e9b4f21dd9422f6893dec0abf2cca553af509b10cd630f878d3eb99"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d3ff7fc90b98c637bda91c89d51264a3dcf210cade3a2c6f838c7268d7a4ca"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1110e22af8ca26b90bd6364fe4c763329b0ebf1ee213ba32b68c73de5752323d"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86f4e8cca779080f66ff4f191a685ced73d2f72d50216f7112185dc02b90b9b7"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f683ddc7eedd742e2889d2bfb96d69573fde1d92fcb811979cdb7165bb9c7d3"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27623ba66c183eca01bf9ff833875b459cad267aeeb044477fedac35e19ba907"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f606a1881d2663630ea5b8ce2efe2111740df4b687bd78b34a8131baa007f79b"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0b309d1747110feb25d7ed6b01afdec269c647d382c857ef4663bbe6ad95a912"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:136815f06a3ae311fae551c3df1f998a1ebd01ddd424aa5603a4336997629e95"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:14215b71a762336254351b00ec720a8e85cada43b987da5a042e4ce3e82bd68e"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79983512b108e4a164b9c8d34de3992f76d48cadc9554c9e60b43f308988aabe"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-win32.whl", hash = "sha256:c94057af19bc953643a33581844649a7fdab902624d2eb739738a30e2b3e60fc"}, - {file = "charset_normalizer-3.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:55f56e2ebd4e3bc50442fbc0888c9d8c94e4e06a933804e2af3e89e2f9c1c749"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-win32.whl", hash = "sha256:9ae4ef0b3f6b41bad6366fb0ea4fc1d7ed051528e113a60fa2a65a9abb5b1d99"}, - {file = "charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7"}, - {file = "charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67"}, - {file = "charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:dbe03226baf438ac4fda9e2d0715022fd579cb641c4cf639fa40d53b2fe6f3e2"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd9a8bd8900e65504a305bf8ae6fa9fbc66de94178c420791d0293702fce2df7"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b8831399554b92b72af5932cdbbd4ddc55c55f631bb13ff8fe4e6536a06c5c51"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a14969b8691f7998e74663b77b4c36c0337cb1df552da83d5c9004a93afdb574"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dcaf7c1524c0542ee2fc82cc8ec337f7a9f7edee2532421ab200d2b920fc97cf"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:425c5f215d0eecee9a56cdb703203dda90423247421bf0d67125add85d0c4455"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:d5b054862739d276e09928de37c79ddeec42a6e1bfc55863be96a36ba22926f6"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:f3e73a4255342d4eb26ef6df01e3962e73aa29baa3124a8e824c5d3364a65748"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:2f6c34da58ea9c1a9515621f4d9ac379871a8f21168ba1b5e09d74250de5ad62"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:f09cb5a7bbe1ecae6e87901a2eb23e0256bb524a79ccc53eb0b7629fbe7677c4"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:0099d79bdfcf5c1f0c2c72f91516702ebf8b0b8ddd8905f97a8aecf49712c621"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-win32.whl", hash = "sha256:9c98230f5042f4945f957d006edccc2af1e03ed5e37ce7c373f00a5a4daa6149"}, - {file = "charset_normalizer-3.4.0-cp37-cp37m-win_amd64.whl", hash = "sha256:62f60aebecfc7f4b82e3f639a7d1433a20ec32824db2199a11ad4f5e146ef5ee"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:af73657b7a68211996527dbfeffbb0864e043d270580c5aef06dc4b659a4b578"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:cab5d0b79d987c67f3b9e9c53f54a61360422a5a0bc075f43cab5621d530c3b6"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9289fd5dddcf57bab41d044f1756550f9e7cf0c8e373b8cdf0ce8773dc4bd417"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b493a043635eb376e50eedf7818f2f322eabbaa974e948bd8bdd29eb7ef2a51"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fa2566ca27d67c86569e8c85297aaf413ffab85a8960500f12ea34ff98e4c41"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a8e538f46104c815be19c975572d74afb53f29650ea2025bbfaef359d2de2f7f"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fd30dc99682dc2c603c2b315bded2799019cea829f8bf57dc6b61efde6611c8"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2006769bd1640bdf4d5641c69a3d63b71b81445473cac5ded39740a226fa88ab"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:dc15e99b2d8a656f8e666854404f1ba54765871104e50c8e9813af8a7db07f12"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:ab2e5bef076f5a235c3774b4f4028a680432cded7cad37bba0fd90d64b187d19"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:4ec9dd88a5b71abfc74e9df5ebe7921c35cbb3b641181a531ca65cdb5e8e4dea"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:43193c5cda5d612f247172016c4bb71251c784d7a4d9314677186a838ad34858"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:aa693779a8b50cd97570e5a0f343538a8dbd3e496fa5dcb87e29406ad0299654"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-win32.whl", hash = "sha256:7706f5850360ac01d80c89bcef1640683cc12ed87f42579dab6c5d3ed6888613"}, - {file = "charset_normalizer-3.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:c3e446d253bd88f6377260d07c895816ebf33ffffd56c1c792b13bff9c3e1ade"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:980b4f289d1d90ca5efcf07958d3eb38ed9c0b7676bf2831a54d4f66f9c27dfa"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f28f891ccd15c514a0981f3b9db9aa23d62fe1a99997512b0491d2ed323d229a"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8aacce6e2e1edcb6ac625fb0f8c3a9570ccc7bfba1f63419b3769ccf6a00ed0"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd7af3717683bea4c87acd8c0d3d5b44d56120b26fd3f8a692bdd2d5260c620a"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ff2ed8194587faf56555927b3aa10e6fb69d931e33953943bc4f837dfee2242"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e91f541a85298cf35433bf66f3fab2a4a2cff05c127eeca4af174f6d497f0d4b"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:309a7de0a0ff3040acaebb35ec45d18db4b28232f21998851cfa709eeff49d62"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:285e96d9d53422efc0d7a17c60e59f37fbf3dfa942073f666db4ac71e8d726d0"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:5d447056e2ca60382d460a604b6302d8db69476fd2015c81e7c35417cfabe4cd"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:20587d20f557fe189b7947d8e7ec5afa110ccf72a3128d61a2a387c3313f46be"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:130272c698667a982a5d0e626851ceff662565379baf0ff2cc58067b81d4f11d"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:ab22fbd9765e6954bc0bcff24c25ff71dcbfdb185fcdaca49e81bac68fe724d3"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7782afc9b6b42200f7362858f9e73b1f8316afb276d316336c0ec3bd73312742"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-win32.whl", hash = "sha256:2de62e8801ddfff069cd5c504ce3bc9672b23266597d4e4f50eda28846c322f2"}, - {file = "charset_normalizer-3.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:95c3c157765b031331dd4db3c775e58deaee050a3042fcad72cbc4189d7c8dca"}, - {file = "charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079"}, - {file = "charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f"}, + {file = "charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b"}, + {file = "charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35"}, + {file = "charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407"}, + {file = "charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f30bf9fd9be89ecb2360c7d94a711f00c09b976258846efe40db3d05828e8089"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:97f68b8d6831127e4787ad15e6757232e14e12060bec17091b85eb1486b91d8d"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7974a0b5ecd505609e3b19742b60cee7aa2aa2fb3151bc917e6e2646d7667dcf"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc54db6c8593ef7d4b2a331b58653356cf04f67c960f584edb7c3d8c97e8f39e"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:311f30128d7d333eebd7896965bfcfbd0065f1716ec92bd5638d7748eb6f936a"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:7d053096f67cd1241601111b698f5cad775f97ab25d81567d3f59219b5f1adbd"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:807f52c1f798eef6cf26beb819eeb8819b1622ddfeef9d0977a8502d4db6d534"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:dccbe65bd2f7f7ec22c4ff99ed56faa1e9f785482b9bbd7c717e26fd723a1d1e"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:2fb9bd477fdea8684f78791a6de97a953c51831ee2981f8e4f583ff3b9d9687e"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:01732659ba9b5b873fc117534143e4feefecf3b2078b0a6a2e925271bb6f4cfa"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-win32.whl", hash = "sha256:7a4f97a081603d2050bfaffdefa5b02a9ec823f8348a572e39032caa8404a487"}, + {file = "charset_normalizer-3.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:7b1bef6280950ee6c177b326508f86cad7ad4dff12454483b51d8b7d673a2c5d"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ecddf25bee22fe4fe3737a399d0d177d72bc22be6913acfab364b40bce1ba83c"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c60ca7339acd497a55b0ea5d506b2a2612afb2826560416f6894e8b5770d4a9"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b7b2d86dd06bfc2ade3312a83a5c364c7ec2e3498f8734282c6c3d4b07b346b8"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd78cfcda14a1ef52584dbb008f7ac81c1328c0f58184bf9a84c49c605002da6"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e27f48bcd0957c6d4cb9d6fa6b61d192d0b13d5ef563e5f2ae35feafc0d179c"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01ad647cdd609225c5350561d084b42ddf732f4eeefe6e678765636791e78b9a"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:619a609aa74ae43d90ed2e89bdd784765de0a25ca761b93e196d938b8fd1dbbd"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:89149166622f4db9b4b6a449256291dc87a99ee53151c74cbd82a53c8c2f6ccd"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:7709f51f5f7c853f0fb938bcd3bc59cdfdc5203635ffd18bf354f6967ea0f824"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:345b0426edd4e18138d6528aed636de7a9ed169b4aaf9d61a8c19e39d26838ca"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0907f11d019260cdc3f94fbdb23ff9125f6b5d1039b76003b5b0ac9d6a6c9d5b"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-win32.whl", hash = "sha256:ea0d8d539afa5eb2728aa1932a988a9a7af94f18582ffae4bc10b3fbdad0626e"}, + {file = "charset_normalizer-3.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:329ce159e82018d646c7ac45b01a430369d526569ec08516081727a20e9e4af4"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b97e690a2118911e39b4042088092771b4ae3fc3aa86518f84b8cf6888dbdb41"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78baa6d91634dfb69ec52a463534bc0df05dbd546209b79a3880a34487f4b84f"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a2bc9f351a75ef49d664206d51f8e5ede9da246602dc2d2726837620ea034b2"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75832c08354f595c760a804588b9357d34ec00ba1c940c15e31e96d902093770"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0af291f4fe114be0280cdd29d533696a77b5b49cfde5467176ecab32353395c4"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0167ddc8ab6508fe81860a57dd472b2ef4060e8d378f0cc555707126830f2537"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2a75d49014d118e4198bcee5ee0a6f25856b29b12dbf7cd012791f8a6cc5c496"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:363e2f92b0f0174b2f8238240a1a30142e3db7b957a5dd5689b0e75fb717cc78"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ab36c8eb7e454e34e60eb55ca5d241a5d18b2c6244f6827a30e451c42410b5f7"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:4c0907b1928a36d5a998d72d64d8eaa7244989f7aaaf947500d3a800c83a3fd6"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:04432ad9479fa40ec0f387795ddad4437a2b50417c69fa275e212933519ff294"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-win32.whl", hash = "sha256:3bed14e9c89dcb10e8f3a29f9ccac4955aebe93c71ae803af79265c9ca5644c5"}, + {file = "charset_normalizer-3.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:49402233c892a461407c512a19435d1ce275543138294f7ef013f0b63d5d3765"}, + {file = "charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85"}, + {file = "charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3"}, ] [[package]] name = "click" -version = "8.1.7" +version = "8.1.8" description = "Composable command line interface toolkit" optional = false python-versions = ">=3.7" files = [ - {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, - {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, + {file = "click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2"}, + {file = "click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a"}, ] [package.dependencies] @@ -201,13 +188,13 @@ files = [ [[package]] name = "databricks-sql-connector" -version = "4.0.0b4" +version = "4.0.0" description = "Databricks SQL Connector for Python" optional = false python-versions = "<4.0.0,>=3.8.0" files = [ - {file = "databricks_sql_connector-4.0.0b4-py3-none-any.whl", hash = "sha256:e5f8e9bf3e73405190879b3c9d4962b2a19aaeeb5892ac3130189091e53d7104"}, - {file = "databricks_sql_connector-4.0.0b4.tar.gz", hash = "sha256:465e50aed29d7947fcd664f09d8b056157bbe7988e1518cbec08a53921c48774"}, + {file = "databricks_sql_connector-4.0.0-py3-none-any.whl", hash = "sha256:798ebc740e992eaf435754510d1035872d3ebbc8c5cb597aa939217220463236"}, + {file = "databricks_sql_connector-4.0.0.tar.gz", hash = "sha256:3634fe3d19ee4641cdf76a77854573d9fe234ccdebd20230aaf94053397bc693"}, ] [package.dependencies] @@ -224,7 +211,7 @@ thrift = ">=0.16.0,<0.21.0" urllib3 = ">=1.26" [package.extras] -pyarrow = ["pyarrow (>=14.0.1,<17)"] +pyarrow = ["pyarrow (>=14.0.1)"] [[package]] name = "dill" @@ -454,49 +441,55 @@ files = [ [[package]] name = "mypy" -version = "1.13.0" +version = "1.14.1" description = "Optional static typing for Python" optional = false python-versions = ">=3.8" files = [ - {file = "mypy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6607e0f1dd1fb7f0aca14d936d13fd19eba5e17e1cd2a14f808fa5f8f6d8f60a"}, - {file = "mypy-1.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a21be69bd26fa81b1f80a61ee7ab05b076c674d9b18fb56239d72e21d9f4c80"}, - {file = "mypy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b2353a44d2179846a096e25691d54d59904559f4232519d420d64da6828a3a7"}, - {file = "mypy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0730d1c6a2739d4511dc4253f8274cdd140c55c32dfb0a4cf8b7a43f40abfa6f"}, - {file = "mypy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:c5fc54dbb712ff5e5a0fca797e6e0aa25726c7e72c6a5850cfd2adbc1eb0a372"}, - {file = "mypy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:581665e6f3a8a9078f28d5502f4c334c0c8d802ef55ea0e7276a6e409bc0d82d"}, - {file = "mypy-1.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3ddb5b9bf82e05cc9a627e84707b528e5c7caaa1c55c69e175abb15a761cec2d"}, - {file = "mypy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20c7ee0bc0d5a9595c46f38beb04201f2620065a93755704e141fcac9f59db2b"}, - {file = "mypy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3790ded76f0b34bc9c8ba4def8f919dd6a46db0f5a6610fb994fe8efdd447f73"}, - {file = "mypy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51f869f4b6b538229c1d1bcc1dd7d119817206e2bc54e8e374b3dfa202defcca"}, - {file = "mypy-1.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5c7051a3461ae84dfb5dd15eff5094640c61c5f22257c8b766794e6dd85e72d5"}, - {file = "mypy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:39bb21c69a5d6342f4ce526e4584bc5c197fd20a60d14a8624d8743fffb9472e"}, - {file = "mypy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:164f28cb9d6367439031f4c81e84d3ccaa1e19232d9d05d37cb0bd880d3f93c2"}, - {file = "mypy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a4c1bfcdbce96ff5d96fc9b08e3831acb30dc44ab02671eca5953eadad07d6d0"}, - {file = "mypy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:a0affb3a79a256b4183ba09811e3577c5163ed06685e4d4b46429a271ba174d2"}, - {file = "mypy-1.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a7b44178c9760ce1a43f544e595d35ed61ac2c3de306599fa59b38a6048e1aa7"}, - {file = "mypy-1.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d5092efb8516d08440e36626f0153b5006d4088c1d663d88bf79625af3d1d62"}, - {file = "mypy-1.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2904956dac40ced10931ac967ae63c5089bd498542194b436eb097a9f77bc8"}, - {file = "mypy-1.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7bfd8836970d33c2105562650656b6846149374dc8ed77d98424b40b09340ba7"}, - {file = "mypy-1.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:9f73dba9ec77acb86457a8fc04b5239822df0c14a082564737833d2963677dbc"}, - {file = "mypy-1.13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:100fac22ce82925f676a734af0db922ecfea991e1d7ec0ceb1e115ebe501301a"}, - {file = "mypy-1.13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7bcb0bb7f42a978bb323a7c88f1081d1b5dee77ca86f4100735a6f541299d8fb"}, - {file = "mypy-1.13.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bde31fc887c213e223bbfc34328070996061b0833b0a4cfec53745ed61f3519b"}, - {file = "mypy-1.13.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:07de989f89786f62b937851295ed62e51774722e5444a27cecca993fc3f9cd74"}, - {file = "mypy-1.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:4bde84334fbe19bad704b3f5b78c4abd35ff1026f8ba72b29de70dda0916beb6"}, - {file = "mypy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0246bcb1b5de7f08f2826451abd947bf656945209b140d16ed317f65a17dc7dc"}, - {file = "mypy-1.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f5b7deae912cf8b77e990b9280f170381fdfbddf61b4ef80927edd813163732"}, - {file = "mypy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7029881ec6ffb8bc233a4fa364736789582c738217b133f1b55967115288a2bc"}, - {file = "mypy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3e38b980e5681f28f033f3be86b099a247b13c491f14bb8b1e1e134d23bb599d"}, - {file = "mypy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:a6789be98a2017c912ae6ccb77ea553bbaf13d27605d2ca20a76dfbced631b24"}, - {file = "mypy-1.13.0-py3-none-any.whl", hash = "sha256:9c250883f9fd81d212e0952c92dbfcc96fc237f4b7c92f56ac81fd48460b3e5a"}, - {file = "mypy-1.13.0.tar.gz", hash = "sha256:0291a61b6fbf3e6673e3405cfcc0e7650bebc7939659fdca2702958038bd835e"}, + {file = "mypy-1.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:52686e37cf13d559f668aa398dd7ddf1f92c5d613e4f8cb262be2fb4fedb0fcb"}, + {file = "mypy-1.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1fb545ca340537d4b45d3eecdb3def05e913299ca72c290326be19b3804b39c0"}, + {file = "mypy-1.14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90716d8b2d1f4cd503309788e51366f07c56635a3309b0f6a32547eaaa36a64d"}, + {file = "mypy-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae753f5c9fef278bcf12e1a564351764f2a6da579d4a81347e1d5a15819997b"}, + {file = "mypy-1.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e0fe0f5feaafcb04505bcf439e991c6d8f1bf8b15f12b05feeed96e9e7bf1427"}, + {file = "mypy-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:7d54bd85b925e501c555a3227f3ec0cfc54ee8b6930bd6141ec872d1c572f81f"}, + {file = "mypy-1.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f995e511de847791c3b11ed90084a7a0aafdc074ab88c5a9711622fe4751138c"}, + {file = "mypy-1.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d64169ec3b8461311f8ce2fd2eb5d33e2d0f2c7b49116259c51d0d96edee48d1"}, + {file = "mypy-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba24549de7b89b6381b91fbc068d798192b1b5201987070319889e93038967a8"}, + {file = "mypy-1.14.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:183cf0a45457d28ff9d758730cd0210419ac27d4d3f285beda038c9083363b1f"}, + {file = "mypy-1.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f2a0ecc86378f45347f586e4163d1769dd81c5a223d577fe351f26b179e148b1"}, + {file = "mypy-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:ad3301ebebec9e8ee7135d8e3109ca76c23752bac1e717bc84cd3836b4bf3eae"}, + {file = "mypy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:30ff5ef8519bbc2e18b3b54521ec319513a26f1bba19a7582e7b1f58a6e69f14"}, + {file = "mypy-1.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb9f255c18052343c70234907e2e532bc7e55a62565d64536dbc7706a20b78b9"}, + {file = "mypy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b4e3413e0bddea671012b063e27591b953d653209e7a4fa5e48759cda77ca11"}, + {file = "mypy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:553c293b1fbdebb6c3c4030589dab9fafb6dfa768995a453d8a5d3b23784af2e"}, + {file = "mypy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fad79bfe3b65fe6a1efaed97b445c3d37f7be9fdc348bdb2d7cac75579607c89"}, + {file = "mypy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:8fa2220e54d2946e94ab6dbb3ba0a992795bd68b16dc852db33028df2b00191b"}, + {file = "mypy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:92c3ed5afb06c3a8e188cb5da4984cab9ec9a77ba956ee419c68a388b4595255"}, + {file = "mypy-1.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dbec574648b3e25f43d23577309b16534431db4ddc09fda50841f1e34e64ed34"}, + {file = "mypy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8c6d94b16d62eb3e947281aa7347d78236688e21081f11de976376cf010eb31a"}, + {file = "mypy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4b19b03fdf54f3c5b2fa474c56b4c13c9dbfb9a2db4370ede7ec11a2c5927d9"}, + {file = "mypy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0c911fde686394753fff899c409fd4e16e9b294c24bfd5e1ea4675deae1ac6fd"}, + {file = "mypy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8b21525cb51671219f5307be85f7e646a153e5acc656e5cebf64bfa076c50107"}, + {file = "mypy-1.14.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7084fb8f1128c76cd9cf68fe5971b37072598e7c31b2f9f95586b65c741a9d31"}, + {file = "mypy-1.14.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8f845a00b4f420f693f870eaee5f3e2692fa84cc8514496114649cfa8fd5e2c6"}, + {file = "mypy-1.14.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:44bf464499f0e3a2d14d58b54674dee25c031703b2ffc35064bd0df2e0fac319"}, + {file = "mypy-1.14.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c99f27732c0b7dc847adb21c9d47ce57eb48fa33a17bc6d7d5c5e9f9e7ae5bac"}, + {file = "mypy-1.14.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:bce23c7377b43602baa0bd22ea3265c49b9ff0b76eb315d6c34721af4cdf1d9b"}, + {file = "mypy-1.14.1-cp38-cp38-win_amd64.whl", hash = "sha256:8edc07eeade7ebc771ff9cf6b211b9a7d93687ff892150cb5692e4f4272b0837"}, + {file = "mypy-1.14.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3888a1816d69f7ab92092f785a462944b3ca16d7c470d564165fe703b0970c35"}, + {file = "mypy-1.14.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:46c756a444117c43ee984bd055db99e498bc613a70bbbc120272bd13ca579fbc"}, + {file = "mypy-1.14.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:27fc248022907e72abfd8e22ab1f10e903915ff69961174784a3900a8cba9ad9"}, + {file = "mypy-1.14.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:499d6a72fb7e5de92218db961f1a66d5f11783f9ae549d214617edab5d4dbdbb"}, + {file = "mypy-1.14.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:57961db9795eb566dc1d1b4e9139ebc4c6b0cb6e7254ecde69d1552bf7613f60"}, + {file = "mypy-1.14.1-cp39-cp39-win_amd64.whl", hash = "sha256:07ba89fdcc9451f2ebb02853deb6aaaa3d2239a236669a63ab3801bbf923ef5c"}, + {file = "mypy-1.14.1-py3-none-any.whl", hash = "sha256:b66a60cc4073aeb8ae00057f9c1f64d49e90f918fbcef9a977eb121da8b8f1d1"}, + {file = "mypy-1.14.1.tar.gz", hash = "sha256:7ec88144fe9b510e8475ec2f5f251992690fcf89ccb4500b214b4226abcd32d6"}, ] [package.dependencies] -mypy-extensions = ">=1.0.0" +mypy_extensions = ">=1.0.0" tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} -typing-extensions = ">=4.6.0" +typing_extensions = ">=4.6.0" [package.extras] dmypy = ["psutil (>=4.0)"] @@ -925,13 +918,13 @@ use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] [[package]] name = "six" -version = "1.16.0" +version = "1.17.0" description = "Python 2 and 3 compatibility utilities" optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" files = [ - {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, - {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, + {file = "six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274"}, + {file = "six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81"}, ] [[package]] @@ -1031,13 +1024,43 @@ twisted = ["twisted"] [[package]] name = "tomli" -version = "2.1.0" +version = "2.2.1" description = "A lil' TOML parser" optional = false python-versions = ">=3.8" files = [ - {file = "tomli-2.1.0-py3-none-any.whl", hash = "sha256:a5c57c3d1c56f5ccdf89f6523458f60ef716e210fc47c4cfb188c5ba473e0391"}, - {file = "tomli-2.1.0.tar.gz", hash = "sha256:3f646cae2aec94e17d04973e4249548320197cfabdf130015d023de4b74d8ab8"}, + {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"}, + {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"}, + {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a"}, + {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"}, + {file = "tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e"}, + {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4"}, + {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106"}, + {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8"}, + {file = "tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff"}, + {file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"}, + {file = "tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea"}, + {file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"}, + {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192"}, + {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"}, + {file = "tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77"}, + {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6"}, + {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd"}, + {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e"}, + {file = "tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98"}, + {file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"}, + {file = "tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7"}, + {file = "tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c"}, + {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13"}, + {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281"}, + {file = "tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272"}, + {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140"}, + {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2"}, + {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744"}, + {file = "tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec"}, + {file = "tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69"}, + {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"}, + {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"}, ] [[package]] @@ -1064,13 +1087,13 @@ files = [ [[package]] name = "tzdata" -version = "2024.2" +version = "2025.1" description = "Provider of IANA time zone data" optional = false python-versions = ">=2" files = [ - {file = "tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd"}, - {file = "tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc"}, + {file = "tzdata-2025.1-py2.py3-none-any.whl", hash = "sha256:7e127113816800496f027041c570f50bcd464a020098a3b6b199517772303639"}, + {file = "tzdata-2025.1.tar.gz", hash = "sha256:24894909e88cdb28bd1636c6887801df64cb485bd593f2fd83ef29075a81d694"}, ] [[package]] @@ -1093,4 +1116,4 @@ zstd = ["zstandard (>=0.18.0)"] [metadata] lock-version = "2.0" python-versions = "^3.8.0" -content-hash = "d576c2a936ccdfec116c3f557a50afeeffa908332a5463548e2d331ee0c2974f" +content-hash = "849318c56d9dfde2a220e8d613a1941fd22b161fe491373f6c7df8eedaa967f7" diff --git a/pyproject.toml b/pyproject.toml index 33a3a90..8c1a6a7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,7 +10,7 @@ include = ["CHANGELOG.md"] [tool.poetry.dependencies] python = "^3.8.0" -databricks_sql_connector = { version = "==4.0.0.b4"} +databricks_sql_connector = { version = ">=4.0.0"} pyarrow = { version = ">=14.0.1,<17"} sqlalchemy = { version = "^1.3.24" } From af3220a26228d45bb64456cf7e3521af45c12de2 Mon Sep 17 00:00:00 2001 From: Jothi Prakash Date: Tue, 28 Jan 2025 05:47:50 +0530 Subject: [PATCH 11/11] Bumped up the version (#16) --- CHANGELOG.md | 2 +- pyproject.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index eaec05d..a47280b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Release History -# 1.0.4 +# 1.0.5 (2025-01-27) - All the SQLAlchemy features from `databricks-sql-connector>=4.0.0` have been moved to this `databricks-sqlalchemy` library - Support for SQLAlchemy v1 dialect is provided \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 8c1a6a7..a19ee68 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "databricks-sqlalchemy" -version = "1.0.4" +version = "1.0.5" description = "Databricks SQLAlchemy plugin for Python" authors = ["Databricks "] license = "Apache-2.0"