instructure-pysqlsync 0.8.5.dev0__py3-none-any.whl

instructure_pysqlsync-0.8.5.dev0.dist-info/METADATA

@@ -0,0 +1,244 @@
+Metadata-Version: 2.4
+Name: instructure-pysqlsync
+Version: 0.8.5.dev0
+Summary: Synchronize schema and large volumes of data
+Author-email: "Instructure, Inc." <dapclient@instructure.com>
+Maintainer-email: "Instructure, Inc." <dapclient@instructure.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/instructure-internal/pysqlsync
+Project-URL: Source, https://github.com/instructure-internal/pysqlsync
+Keywords: synchronization,sql-schema,sql-query,sql-insert,database-clients
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Database :: Database Engines/Servers
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: json_strong_typing>=0.4.2
+Requires-Dist: certifi>=2025.11.12; python_version < "3.10"
+Requires-Dist: truststore>=0.10; python_version >= "3.10"
+Requires-Dist: typing_extensions>=4.15; python_version < "3.12"
+Provides-Extra: tsv
+Requires-Dist: tsv2py>=0.7; extra == "tsv"
+Provides-Extra: postgresql
+Requires-Dist: asyncpg>=0.30; extra == "postgresql"
+Provides-Extra: oracle
+Requires-Dist: oracledb>=3.4; extra == "oracle"
+Provides-Extra: mysql
+Requires-Dist: aiomysql>=0.3; extra == "mysql"
+Requires-Dist: PyMySQL[rsa]>=1.1; extra == "mysql"
+Provides-Extra: mssql
+Requires-Dist: pyodbc>=5.3; extra == "mssql"
+Provides-Extra: snowflake
+Requires-Dist: snowflake-connector-python>=3.18; extra == "snowflake"
+Provides-Extra: trino
+Requires-Dist: aiotrino>=0.3; extra == "trino"
+Dynamic: license-file
+
+# pysqlsync: Synchronize schema and large volumes of data over SQL
+
+*pysqlsync* helps you synchronize your target database or data warehouse with a data source, making efficient use of Python language elements and database drivers (client libraries). The library package employs Python data-classes (decorated with `@dataclass`) to define database tables and generate `CREATE`, `DROP`, `INSERT`, `MERGE` and `DELETE` SQL statements. Commands against the database driver are executed with the asynchronous paradigm (`async` and `await`). This can result in an order of magnitude speed increase over traditional methods such as SQLAlchemy when data is inserted or upserted (merged) into, or deleted from a table.
+
+## Use cases
+
+* Formation. Create an initializer SQL script (e.g. ANSI, PostgreSQL or MySQL) from a set of Python `@dataclass` definitions.
+* Discovery. Create a traversable Python object hierarchy (e.g. `Namespace`, `Table`, `Column` and `Constraint` objects) from a database catalog (using `information_schema` or `pg_catalog`).
+* Schema synchronization. Emit SQL statements to mutate the database schema from a source state to a desired target state using `CREATE`, `DROP` and `ALTER`.
+* Data import. Efficiently insert data from a list of objects or tuples of simple types into a database table using `INSERT`, `MERGE` and `DELETE` with multiple arguments, and lists of tuples or collections of objects as input.
+
+## Quick start
+
+First, define the table structure with a standard Python data-class (including dependent data types):
+
+<!-- Example 1 -->
+```python
+class WorkflowState(enum.Enum):
+    active = "active"
+    inactive = "inactive"
+    deleted = "deleted"
+
+
+@dataclasses.dataclass
+class UserTable:
+    id: PrimaryKey[int]
+    updated_at: datetime
+    workflow_state: WorkflowState
+    uuid: uuid.UUID
+    name: str
+    short_name: Annotated[str, MaxLength(255)]
+    homepage_url: Optional[str] = None
+```
+
+The data-class can be defined statically in code, or generated dynamically from input (with `dataclasses.make_dataclass`). Fields can be required or nullable (represented in Python as `None`). All basic data types are supported, including integers (of various widths), floating-point numbers, strings (of fixed or variable length), timestamps (`datetime.datetime` in Python), UUIDs (`uuid.UUID` in Python), enumerations (represented in Python as `enum.Enum`), etc. `list[...]` is supported as a collection type, and composite types (data-classes without a primary key) are also permitted.
+
+Next, instantiate a database engine, open a connection, create the database structure (with a `CREATE TABLE` statement), and populate the database with initial data (with SQL `INSERT` or `COPY`):
+
+<!-- Example 2 -->
+```python
+engine = get_dialect("postgresql")
+parameters = ConnectionParameters(
+    host="localhost",
+    port=5432,
+    username="user.name",
+    password=None,
+    database="database.name",
+)
+options = GeneratorOptions(
+    enum_mode=EnumMode.RELATION, namespaces={tables: "example"}
+)
+
+data = [
+    UserTable(
+        id=1,
+        updated_at=datetime.now(),
+        workflow_state=WorkflowState.active,
+        uuid=uuid.uuid4(),
+        name="Laura Twenty-Four",
+        short_name="Laura",
+    )
+]
+async with engine.create_connection(parameters, options) as conn:
+    await conn.create_objects([UserTable])
+    await conn.insert_data(UserTable, data)
+```
+
+Let's assume the database structure changes. With the help of an `Explorer` instance, discover the objects in the database, and create/drop objects to match the state as captured in the specified Python module:
+
+<!-- Example 3 -->
+```python
+async with engine.create_connection(parameters, options) as conn:
+    await engine.create_explorer(conn).synchronize(module=tables)
+```
+
+Finally, keep the target database content synchronized with data from the source (with the equivalent of SQL `MERGE`):
+
+<!-- Example 4 -->
+```python
+data = [
+    UserTable(
+        id=2,
+        updated_at=datetime.now(),
+        workflow_state=WorkflowState.active,
+        uuid=uuid.uuid4(),
+        name="Zeta Twelve",
+        short_name="Zeta",
+    )
+]
+async with engine.create_connection(parameters, options) as conn:
+    await engine.create_explorer(conn).synchronize(module=tables)
+    await conn.upsert_data(UserTable, data)
+```
+
+In order to boost efficiency, you can insert (or update) data directly from a list of tuples:
+
+<!-- Example 5 -->
+```python
+field_names = ["id", "uuid", "name", "short_name", "workflow_state", "updated_at"]
+field_types = [int, uuid.UUID, str, str, str, datetime]
+rows = [
+    (1, uuid.uuid4(), "Laura Twenty-Four", "Laura", "active", datetime.now()),
+    (2, uuid.uuid4(), "Zeta Twelve", "Zeta", "inactive", datetime.now()),
+]
+async with engine.create_connection(parameters, options) as conn:
+    await engine.create_explorer(conn).synchronize(module=tables)
+    table = conn.get_table(UserTable)
+    await conn.upsert_rows(
+        table,
+        field_names=tuple(field_names),
+        field_types=tuple(field_types),
+        records=rows,
+    )
+```
+
+## Structure and data synchronization
+
+*pysqlsync* supports two modes of operation: structure synchronization and data synchronization.
+
+When performing *structure synchronization*, *pysqlsync* morphs a database source state into a desired target state. The source state is typically obtained with reflection (e.g. extracting metadata from `information_schema` or `pg_catalog`). The target state is defined as a set of Python data-classes either statically or dynamically (e.g. based on a [JSON Schema](https://json-schema.org/)). Comparing source and target state, *pysqlsync* creates a transformation script (predominantly ANSI SQL with vendor-specific extensions such as comments), and runs the script against an asynchronous client such as `asyncpg` or `aiomysql`. This script creates new schemas, structure and enumeration types, tables, columns, constraints, etc. whenever the target state contains items that the source state lacks, and drops database objects when the opposite is true. When there are matching objects (based on qualified name), the object is mutated (e.g. the data type of a column is changed).
+
+Once database structure has been morphed into the desired state, *data synchronization* helps keep a local database state in sync with a remote database state. *pysqlsync* implements insert and upsert functions to handle lists of tuples of data. Each tuple corresponds to a table row, and each tuple member is a column entry. Data in each column may have to be transformed to be suitable for the database dialect, e.g. MySQL would have to transform a `UUID` into a `BINARY(16)`, represented in Python as `bytes` because it has no `uuid` type. These transformation functions are derived in advance such that there is minimum CPU load to process a record (one of possibly billions). Loading data from network/disk to memory may use an efficient parser implementation such as tsv2py, which significantly speeds up parse time for composite types such as `datetime` or `UUID` with the help of SIMD CPU instructions.
+
+## Formation
+
+Formation is the process of generating a series of SQL statements from a collection of Python data-class definitions. Several formation modes are supported.
+
+### Enumerations
+
+`EnumMode` determines how Python enumeration types (subclasses of `enum.Enum`) are converted into database object types. Possible options for the target of an enumeration type are:
+
+* a SQL `ENUM` type created with `CREATE TYPE ... AS ENUM ( ... )` (PostgreSQL), or
+* an inline SQL `ENUM` definition, e.g. `ENUM('a', 'b', 'c')` (MySQL and Oracle), or
+* a SQL data type corresponding to the enumeration value type, and a `CHECK` constraint on the column to block invalid values, or
+* a foreign/primary key relation (reference constraint), coupled with a lookup table, in which the lookup table consists of an identity column acting as the primary key and a unique column storing the enumeration values.
+
+Extensible enumerations (declared with `E | str` or `E | str | None` where `E` is a subclasses of `enum.Enum`) are always expanded into a relation (i.e. separate table) regardless of `EnumMode`.
+
+### Data-classes
+
+`StructMode` determines how to convert composite types that are not mapped into SQL tables. A data-class type may be converted into
+
+* a composite SQL type with `CREATE TYPE ... AS ( ... )` (PostgreSQL), or
+* the SQL `json` type (PostgreSQL), or
+* a text type, e.g. `varchar`, which holds the data as serialized JSON.
+
+### Lists
+
+`ArrayMode` determines how to treat sequence types, such as Python lists, i.e. whether to represent them as
+
+* a SQL `array` type (PostgreSQL), or
+* a JSON array stored in a column with the SQL data type `json` (PostgreSQL), or
+* a serialized JSON string stored in a text column type, e.g. `varchar`.
+
+### Modules
+
+`GeneratorOptions` allows you to pass a mapping between module types and SQL schema identifiers. Objects in each Python module would be transformed into SQL objects in the corresponding SQL schema (namespace).
+
+## Database standard and engine support
+
+* PostgreSQL (with [asyncpg](https://magicstack.github.io/asyncpg/))
+* Microsoft SQL Server (with [pyodbc](https://github.com/mkleehammer/pyodbc/wiki), requires [ODBC Driver 18](https://learn.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server) or later)
+* Oracle (with [oracledb](https://python-oracledb.readthedocs.io/))
+* MySQL (with [aiomysql](https://aiomysql.readthedocs.io/))
+
+When calling `str()` on Python objects such as `Table`, `Column` or `Constraint`, the library returns an ANSI-compliant representation.
+
+## Python classes for database objects
+
+*pysqlsync* features several Python classes that correspond to database objects:
+
+* `Catalog` captures a database state of possibly several namespaces.
+* `Namespace` corresponds to a database schema in engines that feature schemas (e.g. PostgreSQL).
+* `Table` represents a database table with a primary key, several columns and constraints.
+* `Column` objects declare data type and nullability, and a possibly hold a default value.
+* `StructType` and `StructMember` represent composite types in engines that support them (e.g. PostgreSQL).
+* `EnumType` captures enumeration types for engines that represent them as their own type (e.g. PostgreSQL).
+
+The collection of database objects represents a current structure, which may morph into a target structure. Some of the objects may be vendor-specific, e.g. MySQL has its own `MySQLColumn` type and PostgreSQL has its own `PostgreSQLTable` type.
+
+All objects are identified either with a local ID (e.g. namespaces and columns) or a qualified ID (e.g. tables). When the database engine lacks namespace support, qualified IDs map to a prefix, e.g. `canvas.accounts` (table `accounts` in namespace `canvas`) becomes `canvas__accounts` (a table with no namespace).
+
+## Dialects
+
+pysqlsync comes with several database dialects shipped with the library. However, it is possible to create and register new dialects that behave the same way as built-in dialects. In terms of capabilities, there are no differences between built-in and user-defined dialects.
+
+If you are about to write integration for a new database dialect, it is recommended that you take one of the existing dialects (e.g. PostgreSQL, Microsoft SQL Server, Oracle or MySQL), and use it as a template. For more information, explore the folder `pysqlsync/dialect`.
+
+## Upstream
+
+This is an internal fork of [hunyadi/pysqlsync](https://github.com/hunyadi/pysqlsync). To track upstream changes, add the original repository as a remote:
+
+```sh
+git remote add hunyadi git@github.com:hunyadi/pysqlsync.git
+```

instructure_pysqlsync-0.8.5.dev0.dist-info/RECORD

@@ -0,0 +1,102 @@
+instructure_pysqlsync-0.8.5.dev0.dist-info/licenses/LICENSE,sha256=xSBMIQHJdUgGKSlJVCOFBtPAhszPF6ALKw-57ap98dg,1101
+pysqlsync/__init__.py,sha256=rpfC54e7Urif20RCNZkMJ8nTYz2IsMSLVmWWKrJyUW8,531
+pysqlsync/base.py,sha256=5wrM7oL_AOjAHmxsbo0yDZMmT-6JWBnltU30C6us1rU,51669
+pysqlsync/connection.py,sha256=kl_JSHGJBnEr9E-7IW6lXQaA3XyRBlE0-NWBBaXGlPU,3559
+pysqlsync/factory.py,sha256=E20P7pXuuzcXsf_ZOumnL-Z-FSRraD8GnQLzRCeE8L0,5752
+pysqlsync/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/python_types.py,sha256=WTKqyR6YW4XaKdNHBAdDUMjWcqLaP-ImoPD9hIUkBWQ,6378
+pysqlsync/resultset.py,sha256=GWhrbkgxX4EMmLMBddijziKW5BXX51ONj_QW3TlQrCQ,3623
+pysqlsync/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/data/exchange.py,sha256=kdk48CwIxTjbL_ZPLs4-fj8Shs9VUNGRB08pb6HimT8,5838
+pysqlsync/data/generator.py,sha256=Fn_B7rVlbaYHyiuJeWiQ548EDW2Kes9xJLjMLt5AIAU,10880
+pysqlsync/dialect/README.md,sha256=3eI3Dzz6A_TJgxJOzEmsdf-WrDsezZZf7TrjSK-wYD8,5085
+pysqlsync/dialect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/delta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/delta/data_types.py,sha256=w9_T3F-UgeXxGJC37EGFaMvVLLs45FgMq9bsFJ3vZk4,999
+pysqlsync/dialect/delta/dependency.py,sha256=RRFd0-afoU-0e2QclMA-n_KxjkujWW1xS2XPjr2rbbw,195
+pysqlsync/dialect/delta/engine.py,sha256=jeETbyhKzqlAazepJGGFhmfFzK29tLSdBqQJa8BIOMs,487
+pysqlsync/dialect/delta/generator.py,sha256=34E4MMD-flXz6R2GojuvUqJjrN5PapvjKuseRXTMT3E,2469
+pysqlsync/dialect/delta/object_types.py,sha256=jrZVYgHWpHNhGyXK85e4AEtR3zR0b_2emC2NHDPSQZE,2585
+pysqlsync/dialect/mssql/README.md,sha256=xGJSdV_K4m8F6SWnyCQw2QPvUUEyzJrQ1G5nshs8wMw,789
+pysqlsync/dialect/mssql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/mssql/connection.py,sha256=7tKlD6EoUaqurFreaNuqrJ09lBYyNlmEh3zBP56Fs74,5213
+pysqlsync/dialect/mssql/data_types.py,sha256=ADFzn49IR82h_46CjF9yCg-MU6y5N0ZZCdRXtn8FVnQ,3522
+pysqlsync/dialect/mssql/dependency.py,sha256=wBzhjUWTYvbC4gKdSdCe_8ePf1ds3SYwdryFK4DXJPY,258
+pysqlsync/dialect/mssql/discovery.py,sha256=hFcGp01RNAbFxIzLZPhaDyLkHc9w2KKepWkJjfgiOo8,4293
+pysqlsync/dialect/mssql/engine.py,sha256=Zcz8Bd3XO3oMhhm6i8D6AGCjHQWohh96vlMKrJKEQ1k,552
+pysqlsync/dialect/mssql/generator.py,sha256=2SajU-FhuvJ8Gs_ehk5_XL13V6OfcMmEvNQb081qyrU,3370
+pysqlsync/dialect/mssql/mutation.py,sha256=nJU2uRxw0zsUt5PIXVPIhB9zvu-QJgv9R4x8v8VQpXY,1815
+pysqlsync/dialect/mssql/object_types.py,sha256=Oio7WIS2GtzyeGWUwIMzSzZ6mM0RBviBM_TT2hwPVyg,4035
+pysqlsync/dialect/mysql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/mysql/connection.py,sha256=7gnlglpjD8BaCS6pbM_3dbXzis1hKNkxz_OWrsix8Ao,4542
+pysqlsync/dialect/mysql/data_types.py,sha256=FNToqK2jeBK5_5RATe8c79v2uvOhBTgdMN50Srx4-gk,1269
+pysqlsync/dialect/mysql/dependency.py,sha256=OygsSx_shXpU7T2rNi9MVlEe-sCP5wuMtEC_V4_BdLM,317
+pysqlsync/dialect/mysql/discovery.py,sha256=52VhOgEN8XhaheZfgvDk8xfuuIpe21XWs2pGFLdsPuU,6441
+pysqlsync/dialect/mysql/engine.py,sha256=U6giltZzISuYQ1sMbWOaRcZUhFWH3z_qEGF00mL3rLc,552
+pysqlsync/dialect/mysql/generator.py,sha256=d6jPfFjJo7DYP8GR5ph5Gwa2MIA6WrSN3StPyLDWmhg,6067
+pysqlsync/dialect/mysql/mutation.py,sha256=9LMFkFf7uFsQ0Yb3yaMuXZZGpj7FXcVjTIN51LwamDY,2947
+pysqlsync/dialect/mysql/object_types.py,sha256=A016_OzwwgBxNYEC-yH31ecTdAY39dK7TI45iJSgmZc,2604
+pysqlsync/dialect/oracle/README.md,sha256=O_AFq4bvKm_C6PRsgdlphvtzVYCA2Fh-cc1kzMnBfnM,627
+pysqlsync/dialect/oracle/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/oracle/connection.py,sha256=VijCFOzxvH7-GhxP3thGOCbzr2TbMO9-Y6Uh38KaeOI,4780
+pysqlsync/dialect/oracle/data_types.py,sha256=0xzyCkIOOdk5zVTfJSTYM40TcceVVZ9VJH6aN8k1GbY,3399
+pysqlsync/dialect/oracle/dependency.py,sha256=tfCfWJLkB1qKNBlXiDN4Qfx8Q8Cd6XuPgMhLRFWE1Nc,246
+pysqlsync/dialect/oracle/discovery.py,sha256=05Ko1FaQZ30Z4hn-kT4EzVxinqslqSrAdUjUacJVb5U,8554
+pysqlsync/dialect/oracle/engine.py,sha256=PI3C1Fjbl7bZ83GBilt0G0zwJdoEUkwSDH1fjTiWI10,560
+pysqlsync/dialect/oracle/generator.py,sha256=08QaFOOxKRf767nDBBK5qj8haWfzToIN5gZUnTRjFmg,4105
+pysqlsync/dialect/oracle/mutation.py,sha256=dlFfCsUzVupcbBItqZE1GTQjH3P91HiU6p6YU3fFoc4,1380
+pysqlsync/dialect/oracle/object_types.py,sha256=f83xzT6VXjLcWHxHclUQE2NxLBNmBxEWsbXiJ0ybGoY,1864
+pysqlsync/dialect/postgresql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/postgresql/connection.py,sha256=kbie90eWiumsFj-xkA7jGDZci6pJJeVEE41RDV6BU38,5000
+pysqlsync/dialect/postgresql/data_types.py,sha256=6xOCIuKEaVO2pOLF1fa7hz3KfI9bR3xia4Db695V1EE,145
+pysqlsync/dialect/postgresql/dependency.py,sha256=dWnPZBvAW5J-5KNRCvX0yomz9Yf2g7Z0cY3ZRGVmhJk,249
+pysqlsync/dialect/postgresql/discovery.py,sha256=qdhFJkP_bMLSfIpzbunf2RFrkdMMmqXWcZ89dqmmeBc,15925
+pysqlsync/dialect/postgresql/engine.py,sha256=51q2rqXc9N_AiD6C7f1RgorGXEI-r7N7X97a32o0Bt4,592
+pysqlsync/dialect/postgresql/generator.py,sha256=ayVEMGhs7ANRIjExggVFeBLKXjywzhzr02f_MPYBIzE,4114
+pysqlsync/dialect/postgresql/mutation.py,sha256=MRR3l8Is00CzyUsCNj2LgydoYvigb9DZMaEjk5-ort8,3821
+pysqlsync/dialect/postgresql/object_types.py,sha256=Cs77Yymp21GuncIfRwCDbxzgkbkM5mUP__c-nw_jKk4,2871
+pysqlsync/dialect/redshift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/redshift/connection.py,sha256=WXe7_lkr-V_yQwNgp5hLDwJ_FZzTWK2aup3wgmHzY2k,5547
+pysqlsync/dialect/redshift/data_types.py,sha256=rXVPJv_7GgXx322baz0Ar_UktqSFpJPHBa10blDgoIk,303
+pysqlsync/dialect/redshift/dependency.py,sha256=Kwbs95W67Zo0y3yFVazsQ3lPNOO8cWipKBTJQqRy2mM,262
+pysqlsync/dialect/redshift/engine.py,sha256=WFRG0vgLGNYyWt_blXcVyWsaqpw2vNoB4tRzuNN76xo,592
+pysqlsync/dialect/redshift/generator.py,sha256=X521WminSm-bcQj_LQ8qAbY0pSJnTpKgEqgbhdSVZ54,3044
+pysqlsync/dialect/snowflake/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/snowflake/data_types.py,sha256=GZbiEvz11S5ihIZ9Dk-mu1RlN5lZQUbY_K77uMNWjgU,449
+pysqlsync/dialect/snowflake/dependency.py,sha256=SnWrzpztNYSyc4tS8eAIDLzor9BpsYshXir9aQBDMfo,250
+pysqlsync/dialect/snowflake/engine.py,sha256=fiw7ln17C-js4zmgbkRefG2vkT-yJXbH3KR0zM0B-bM,503
+pysqlsync/dialect/snowflake/generator.py,sha256=aKUAGE4ER0-w2rYN7YBpcULV9JjVsk8pAsjwgemRFJc,2188
+pysqlsync/dialect/snowflake/object_types.py,sha256=OYsLqpwCOH1ZP-kHxUwCJWptS8KtPQHFYukOwopB0Xg,2589
+pysqlsync/dialect/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/test/dependency.py,sha256=avIdCXuaLjvMUdVKqH3LWM-NLT_X6MQBOn1MmExaXAQ,333
+pysqlsync/dialect/trino/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/dialect/trino/connection.py,sha256=C6GnIqHdL0tduELDz6JJQXtT1ulTATTFyjYnsHJHB8I,2679
+pysqlsync/dialect/trino/dependency.py,sha256=a2SpMwtbjWcvKVQagJSN8qNQtqnzYLPjlPrM-JX__Vw,269
+pysqlsync/dialect/trino/discovery.py,sha256=yAq4hV3j2WdFYWxbq2eKPsLz7pc9aaLC1ZE4DjOVi5E,698
+pysqlsync/dialect/trino/engine.py,sha256=KHWbeoywcSfTRs9ZrdAWPDiaexzO5mYoACOwIJParAw,552
+pysqlsync/dialect/trino/generator.py,sha256=qPYQ7yp8C97eXQAvMf9co8FGucdqRmxAlKu0_ZjwO5E,1147
+pysqlsync/formation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/formation/constraints.py,sha256=QweHKFZjSFdz1CkzyfuoD1c2iI4l3wTV4I3RZVpBd_g,2422
+pysqlsync/formation/data_types.py,sha256=c_6UeeKrJPcGfeHSEnySzgoBqbt4aDMD2iL-h9VoZug,7416
+pysqlsync/formation/discovery.py,sha256=Ln9m4EVfqyeDE37gwjJ-4sHRESRZ8ONPqfug6em_l4U,16328
+pysqlsync/formation/inspection.py,sha256=EWVZ_WvHAfc8LbDboMwkXyJssGkAdPhMkOiyx4QcSsQ,5571
+pysqlsync/formation/mutation.py,sha256=arnWK6p2M2eUnK2NCe5-n6f51BfVPgds2oio9kJ62nk,13349
+pysqlsync/formation/object_dict.py,sha256=Tw53-avo-H6XZJErxp524-2LgYacQP748fEJPeLJJtM,2564
+pysqlsync/formation/object_types.py,sha256=ZKCxFZGT1f0ia7wTQgNcF0Nd60Dj6RVtJk_ek0mOuF4,27821
+pysqlsync/formation/py_to_sql.py,sha256=CAkkvfneao1FXWViocl8qWSL1E7rjQywRDFVRVQD2jk,46883
+pysqlsync/formation/sql_to_py.py,sha256=Mgf8sr_WSR8rgRbiH_vI4ipqg9uvI_8GOJDnBDuaQ0M,6908
+pysqlsync/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/model/data_types.py,sha256=eSnBBsmUoGT3o3tprnl4l9mbf4Vij5wFTrqwYqIl_yc,11100
+pysqlsync/model/entity_types.py,sha256=nF5ML-LYECwB2B6xCPR1WHGkea1tE6ENThUtLxjuoxs,2207
+pysqlsync/model/id_types.py,sha256=LNSu0CLuR2dSQTvurldoePi7rQGqpKm5sDe2VlpJlMc,4357
+pysqlsync/model/key_types.py,sha256=SdUTwh5iiofEU_PYXMpBYLR2Iz1DKb9p-WV7l7kxMxI,739
+pysqlsync/model/properties.py,sha256=eGb3Y3nT7dxD_z70FF6Moq4Y1TUTF4x09725elFhQkY,7486
+pysqlsync/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysqlsync/util/dataclasses.py,sha256=1AHp3eKa9LIf-CI7eyerQMm0ztqRaHytgSAcTC3dcf8,2773
+pysqlsync/util/dispatch.py,sha256=17pL9-HubzPQvGmlT_wP49kXsWWE5zei2SfxoOpLLZk,902
+pysqlsync/util/typing.py,sha256=SjILp7FG733KxddoJjAuUvc8YgimH2lEA6-YL-pZUws,478
+instructure_pysqlsync-0.8.5.dev0.dist-info/METADATA,sha256=dM0fGzwEhNVdfsxaNGQmTPBhLxLKka9fMyU4zBGWeNU,13855
+instructure_pysqlsync-0.8.5.dev0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+instructure_pysqlsync-0.8.5.dev0.dist-info/top_level.txt,sha256=w9A2WRkEAcGaTDp05I6BtMr8RfOW2MxKB4eGxes4TIQ,10
+instructure_pysqlsync-0.8.5.dev0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+instructure_pysqlsync-0.8.5.dev0.dist-info/RECORD,,

instructure_pysqlsync-0.8.5.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

instructure_pysqlsync-0.8.5.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2025 Levente Hunyadi; 2026 Instructure, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

instructure_pysqlsync-0.8.5.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pysqlsync

instructure_pysqlsync-0.8.5.dev0.dist-info/zip-safe

@@ -0,0 +1 @@
+

pysqlsync/__init__.py

@@ -0,0 +1,15 @@
+"""
+pysqlsync: Synchronize schema and large volumes of data.
+
+This library helps you synchronize your target database or data warehouse with a data source, making efficient use
+of Python language elements and database drivers (client libraries).
+
+:see: https://github.com/instructure-internal/pysqlsync
+"""
+
+__version__ = "0.8.5.dev0"
+__author__ = "Instructure, Inc."
+__copyright__ = "Copyright 2023-2025, Levente Hunyadi; 2026 Instructure, Inc."
+__license__ = "MIT"
+__maintainer__ = "Instructure, Inc."
+__status__ = "Development"