Pyzzel 0.1.1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
pyzzel/sql/builder.py ADDED
@@ -0,0 +1,357 @@
1
+ """Pure PostgreSQL SQL statement builders."""
2
+
3
+ import re
4
+ from collections import namedtuple
5
+ from typing import NamedTuple, Sequence
6
+
7
+ from .conditions import Condition, OrderBy
8
+
9
+
10
+ class Statement(NamedTuple):
11
+ """SQL text and its ordered parameter values."""
12
+
13
+ sql: str
14
+ params: tuple
15
+
16
+
17
+ class ColumnRef(NamedTuple):
18
+ table: str
19
+ name: str
20
+ alias: str | None = None
21
+
22
+
23
+ class Join(namedtuple(
24
+ "Join", ("kind", "table", "left_table", "left_column", "right_table", "right_column")
25
+ )):
26
+ __slots__ = ()
27
+
28
+ def __new__(cls, kind, table, left_table, left_column, right_table, right_column):
29
+ if kind not in ("INNER", "LEFT"):
30
+ raise ValueError(f"Invalid join kind: {kind!r}")
31
+ return super().__new__(cls, kind, table, left_table, left_column, right_table, right_column)
32
+
33
+
34
+ class ColumnSpec(NamedTuple):
35
+ """Column definition; default is a trusted Pyzzel SQL expression, never user input."""
36
+
37
+ name: str
38
+ sql_type: str
39
+ primary_key: bool = False
40
+ identity: bool = False
41
+ nullable: bool = True
42
+ unique: bool = False
43
+ default: str | None = None
44
+ foreign_key: tuple[str, str] | None = None
45
+ on_delete: str | None = None
46
+
47
+
48
+ _IDENTIFIER = re.compile(r"^[A-Za-z_][A-Za-z0-9_]{0,62}$")
49
+ _SQL_TYPE = re.compile(r"^[A-Z][A-Z0-9_ ]*(\(\d+(,\s*\d+)?\))?$")
50
+
51
+
52
+ def quote_ident(name: str) -> str:
53
+ """Validate and double-quote a PostgreSQL identifier."""
54
+ if not isinstance(name, str) or _IDENTIFIER.fullmatch(name) is None:
55
+ raise ValueError(f"Invalid identifier: {name!r}")
56
+ return f'"{name}"'
57
+
58
+
59
+ def check_default_expression(expression):
60
+ """Trusted text written by the developer, never user input."""
61
+ if (
62
+ not isinstance(expression, str)
63
+ or not expression.strip()
64
+ or any(token in expression for token in (";", "--", "/*"))
65
+ ):
66
+ raise ValueError("Invalid DEFAULT expression")
67
+ return expression
68
+
69
+
70
+ def insert(table, values: dict, returning: Sequence[str] | None = None) -> Statement:
71
+ """Build a parameterized INSERT statement."""
72
+ table_sql = quote_ident(table)
73
+ returning_sql = "*" if returning is None else ", ".join(quote_ident(name) for name in returning)
74
+ if not values:
75
+ return Statement(f"INSERT INTO {table_sql} DEFAULT VALUES RETURNING {returning_sql}", ())
76
+ names = [quote_ident(name) for name in values]
77
+ placeholders = ", ".join(["%s"] * len(values))
78
+ sql = f"INSERT INTO {table_sql} ({', '.join(names)}) VALUES ({placeholders}) RETURNING {returning_sql}"
79
+ return Statement(sql, tuple(values.values()))
80
+
81
+
82
+ def insert_many(
83
+ table,
84
+ columns: Sequence[str],
85
+ rows: Sequence[Sequence],
86
+ returning: Sequence[str] | None = None,
87
+ ) -> Statement:
88
+ """Build one parameterized multi-row INSERT statement."""
89
+ if not columns:
90
+ raise ValueError("INSERT requires at least one column")
91
+ if not rows:
92
+ raise ValueError("INSERT requires at least one row")
93
+ width = len(columns)
94
+ if any(len(row) != width for row in rows):
95
+ raise ValueError("Every INSERT row must match the column count")
96
+ columns_sql = ", ".join(quote_ident(name) for name in columns)
97
+ row_sql = "(" + ", ".join(["%s"] * width) + ")"
98
+ values_sql = ", ".join([row_sql] * len(rows))
99
+ returning_sql = "*" if returning is None else ", ".join(
100
+ quote_ident(name) for name in returning
101
+ )
102
+ sql = (
103
+ f"INSERT INTO {quote_ident(table)} ({columns_sql}) "
104
+ f"VALUES {values_sql} RETURNING {returning_sql}"
105
+ )
106
+ return Statement(sql, tuple(value for row in rows for value in row))
107
+
108
+
109
+ def select_by_pk(table, columns: Sequence[str], pk_column: str, pk_value) -> Statement:
110
+ """Build a parameterized SELECT by primary key."""
111
+ if not columns:
112
+ raise ValueError("SELECT requires at least one column")
113
+ columns_sql = ", ".join(quote_ident(column) for column in columns)
114
+ return Statement(
115
+ f"SELECT {columns_sql} FROM {quote_ident(table)} WHERE {quote_ident(pk_column)} = %s",
116
+ (pk_value,),
117
+ )
118
+
119
+
120
+ def _validate_limit(value, label):
121
+ if value is not None and (
122
+ isinstance(value, bool) or not isinstance(value, int) or value < 0
123
+ ):
124
+ raise ValueError(f"{label} must be an int greater than or equal to 0")
125
+
126
+
127
+ def _joins_sql(joins):
128
+ sql = ""
129
+ for join in joins:
130
+ if not isinstance(join, Join):
131
+ raise ValueError("joins must contain Join values")
132
+ if join.kind not in ("INNER", "LEFT"):
133
+ raise ValueError(f"Invalid join kind: {join.kind!r}")
134
+ sql += (
135
+ f" {join.kind} JOIN {quote_ident(join.table)} ON "
136
+ f"{quote_ident(join.left_table)}.{quote_ident(join.left_column)} = "
137
+ f"{quote_ident(join.right_table)}.{quote_ident(join.right_column)}"
138
+ )
139
+ return sql
140
+
141
+
142
+ def select(
143
+ table,
144
+ columns: Sequence[str],
145
+ where: Condition | None = None,
146
+ order_by: Sequence[OrderBy] = (),
147
+ limit: int | None = None,
148
+ offset: int | None = None,
149
+ joins=(),
150
+ distinct=False,
151
+ ) -> Statement:
152
+ """Build a parameterized SELECT statement."""
153
+ if not columns:
154
+ raise ValueError("SELECT requires at least one column")
155
+ _validate_limit(limit, "limit")
156
+ _validate_limit(offset, "offset")
157
+ joined = bool(joins)
158
+ column_sql = []
159
+ for column in columns:
160
+ if isinstance(column, ColumnRef):
161
+ table_sql = quote_ident(column.table)
162
+ if joined:
163
+ rendered = f"{table_sql}.{quote_ident(column.name)}"
164
+ else:
165
+ rendered = quote_ident(column.name)
166
+ if column.alias is not None:
167
+ rendered += f" AS {quote_ident(column.alias)}"
168
+ column_sql.append(rendered)
169
+ elif isinstance(column, str) and not joined:
170
+ column_sql.append(quote_ident(column))
171
+ else:
172
+ raise ValueError("With joins, columns must be ColumnRef values")
173
+ select_prefix = "SELECT DISTINCT" if distinct else "SELECT"
174
+ sql = f"{select_prefix} {', '.join(column_sql)} FROM {quote_ident(table)}"
175
+ sql += _joins_sql(joins)
176
+ params = ()
177
+ if where is not None:
178
+ if not isinstance(where, Condition):
179
+ raise TypeError("where must be a Condition")
180
+ where_sql, where_params = where.render(qualify=joined)
181
+ sql += f" WHERE {where_sql}"
182
+ params += where_params
183
+ if order_by:
184
+ order_terms = []
185
+ for item in order_by:
186
+ if not isinstance(item, OrderBy):
187
+ raise ValueError("order_by items must be OrderBy values")
188
+ if item.direction not in ("ASC", "DESC"):
189
+ raise ValueError("order_by direction must be ASC or DESC")
190
+ if joined:
191
+ if item.table is None:
192
+ raise ValueError("Joined ORDER BY columns need a table")
193
+ order_terms.append(
194
+ f"{quote_ident(item.table)}.{quote_ident(item.column)} {item.direction}"
195
+ )
196
+ else:
197
+ order_terms.append(f"{quote_ident(item.column)} {item.direction}")
198
+ sql += " ORDER BY " + ", ".join(order_terms)
199
+ if limit is not None:
200
+ sql += " LIMIT %s"
201
+ params += (limit,)
202
+ if offset is not None:
203
+ sql += " OFFSET %s"
204
+ params += (offset,)
205
+ return Statement(sql, params)
206
+
207
+
208
+ def count(table, where: Condition | None = None, joins=()) -> Statement:
209
+ """Build a parameterized COUNT(*) statement."""
210
+ sql = f"SELECT COUNT(*) FROM {quote_ident(table)}"
211
+ joined = bool(joins)
212
+ sql += _joins_sql(joins)
213
+ params = ()
214
+ if where is not None:
215
+ if not isinstance(where, Condition):
216
+ raise TypeError("where must be a Condition")
217
+ where_sql, params = where.render(qualify=joined)
218
+ sql += f" WHERE {where_sql}"
219
+ return Statement(sql, params)
220
+
221
+
222
+ def update(
223
+ table,
224
+ changes: dict,
225
+ pk_column: str,
226
+ pk_value,
227
+ version_column: str,
228
+ version_value,
229
+ returning: Sequence[str] | None = None,
230
+ ) -> Statement:
231
+ """Build a version-checked parameterized UPDATE."""
232
+ if not changes:
233
+ raise ValueError("UPDATE requires at least one changed column")
234
+ if pk_column in changes or version_column in changes:
235
+ raise ValueError("Changes cannot include the primary key or version column")
236
+ table_sql = quote_ident(table)
237
+ pk_sql = quote_ident(pk_column)
238
+ version_sql = quote_ident(version_column)
239
+ assignments = [f"{quote_ident(name)} = %s" for name in changes]
240
+ assignments.append(f'{version_sql} = {version_sql} + 1')
241
+ returning_sql = "*" if returning is None else ", ".join(quote_ident(name) for name in returning)
242
+ sql = (
243
+ f"UPDATE {table_sql} SET {', '.join(assignments)} WHERE {pk_sql} = %s "
244
+ f"AND {version_sql} = %s RETURNING {returning_sql}"
245
+ )
246
+ return Statement(sql, (*changes.values(), pk_value, version_value))
247
+
248
+
249
+ def update_where(table, changes, where, version_column="version") -> Statement:
250
+ """Build a parameterized UPDATE for rows matching a condition."""
251
+ if not changes:
252
+ raise ValueError("UPDATE requires at least one changed column")
253
+ if where is None:
254
+ raise ValueError("UPDATE requires a condition")
255
+ if not isinstance(where, Condition):
256
+ raise TypeError("where must be a Condition")
257
+ if version_column in changes:
258
+ raise ValueError("Changes cannot include the version column")
259
+ table_sql = quote_ident(table)
260
+ assignments = [f"{quote_ident(name)} = %s" for name in changes]
261
+ version_sql = quote_ident(version_column)
262
+ assignments.append(f'{version_sql} = {version_sql} + 1')
263
+ where_sql, where_params = where.render()
264
+ return Statement(
265
+ f"UPDATE {table_sql} SET {', '.join(assignments)} WHERE {where_sql}",
266
+ (*changes.values(), *where_params),
267
+ )
268
+
269
+
270
+ def delete_where(table, where) -> Statement:
271
+ """Build a parameterized DELETE for rows matching a condition."""
272
+ if where is None:
273
+ raise ValueError("DELETE requires a condition")
274
+ if not isinstance(where, Condition):
275
+ raise TypeError("where must be a Condition")
276
+ where_sql, params = where.render()
277
+ return Statement(f"DELETE FROM {quote_ident(table)} WHERE {where_sql}", params)
278
+
279
+
280
+ def delete(table, pk_column, pk_value, version_column=None, version_value=None) -> Statement:
281
+ """Build a parameterized DELETE, optionally guarded by a version."""
282
+ if (version_column is None) != (version_value is None):
283
+ raise ValueError("version_column and version_value must be provided together")
284
+ sql = f"DELETE FROM {quote_ident(table)} WHERE {quote_ident(pk_column)} = %s"
285
+ params = (pk_value,)
286
+ if version_column is not None:
287
+ version_sql = quote_ident(version_column)
288
+ sql += f" AND {version_sql} = %s"
289
+ params += (version_value,)
290
+ return Statement(sql, params)
291
+
292
+
293
+ def create_table(table, columns: Sequence[ColumnSpec]) -> str:
294
+ """Build CREATE TABLE SQL from validated column specifications."""
295
+ if not columns:
296
+ raise ValueError("CREATE TABLE requires at least one column")
297
+ names = [column.name for column in columns]
298
+ if len(set(names)) != len(names):
299
+ raise ValueError("Column names must be unique")
300
+ if sum(column.primary_key for column in columns) != 1:
301
+ raise ValueError("Exactly one primary key is required")
302
+
303
+ definitions = [column_definition(column) for column in columns]
304
+ return f'CREATE TABLE IF NOT EXISTS {quote_ident(table)} ({", ".join(definitions)})'
305
+
306
+
307
+ def column_definition(column: ColumnSpec) -> str:
308
+ """Build one validated SQL column definition."""
309
+ name_sql = quote_ident(column.name)
310
+ if not isinstance(column.sql_type, str) or _SQL_TYPE.fullmatch(column.sql_type) is None:
311
+ raise ValueError(f"Invalid SQL type: {column.sql_type!r}")
312
+ if column.identity and not column.primary_key:
313
+ raise ValueError("Identity requires primary_key=True")
314
+ parts = [name_sql, column.sql_type]
315
+ if column.identity:
316
+ parts.append("GENERATED ALWAYS AS IDENTITY")
317
+ if column.primary_key:
318
+ parts.append("PRIMARY KEY")
319
+ elif not column.nullable:
320
+ parts.append("NOT NULL")
321
+ if column.unique:
322
+ parts.append("UNIQUE")
323
+ if column.default is not None:
324
+ parts.extend(("DEFAULT", check_default_expression(column.default)))
325
+ if column.foreign_key is not None:
326
+ if not isinstance(column.foreign_key, tuple) or len(column.foreign_key) != 2:
327
+ raise ValueError("foreign_key must be a (table, column) pair")
328
+ ref_table, ref_column = column.foreign_key
329
+ parts.extend(("REFERENCES", f"{quote_ident(ref_table)} ({quote_ident(ref_column)})"))
330
+ on_delete = column.on_delete or "NO ACTION"
331
+ if on_delete not in ("NO ACTION", "RESTRICT", "CASCADE", "SET NULL"):
332
+ raise ValueError(f"Invalid ON DELETE action: {on_delete!r}")
333
+ if on_delete != "NO ACTION":
334
+ parts.extend(("ON DELETE", on_delete))
335
+ elif column.on_delete not in (None, "NO ACTION"):
336
+ raise ValueError("on_delete requires foreign_key")
337
+ return " ".join(parts)
338
+
339
+
340
+ def index_name(table, column) -> str:
341
+ """Return the deterministic PostgreSQL-safe name for an index."""
342
+ quote_ident(table)
343
+ quote_ident(column)
344
+ key = f"{table}_{column}"
345
+ name = f"ix_{key}"
346
+ if len(name) > 63:
347
+ import zlib
348
+
349
+ name = f"ix_{key[:40]}_{zlib.crc32(key.encode('utf-8')):08x}"
350
+ return name
351
+
352
+
353
+ def create_index(table, column) -> str:
354
+ """Build an idempotent index statement with a PostgreSQL-safe name."""
355
+ table_sql = quote_ident(table)
356
+ column_sql = quote_ident(column)
357
+ return f"CREATE INDEX IF NOT EXISTS {quote_ident(index_name(table, column))} ON {table_sql} ({column_sql})"
@@ -0,0 +1,195 @@
1
+ """Composable, parameterized PostgreSQL query conditions."""
2
+
3
+ from typing import NamedTuple
4
+
5
+
6
+ class Condition:
7
+ """Base class for query conditions."""
8
+
9
+ def render(self, qualify=False) -> tuple[str, tuple]:
10
+ raise NotImplementedError
11
+
12
+ def columns(self) -> list[tuple[str | None, str]]:
13
+ raise NotImplementedError
14
+
15
+ def __and__(self, other):
16
+ if not isinstance(other, Condition):
17
+ return NotImplemented
18
+ left = self.parts if isinstance(self, And) else (self,)
19
+ right = other.parts if isinstance(other, And) else (other,)
20
+ return And(left + right)
21
+
22
+ def __or__(self, other):
23
+ if not isinstance(other, Condition):
24
+ return NotImplemented
25
+ left = self.parts if isinstance(self, Or) else (self,)
26
+ right = other.parts if isinstance(other, Or) else (other,)
27
+ return Or(left + right)
28
+
29
+ def __invert__(self):
30
+ return Not(self)
31
+
32
+ def __bool__(self):
33
+ raise TypeError(
34
+ "Use & | ~ (with parentheses), or and_()/or_(), instead of and/or/not or chained comparisons."
35
+ )
36
+
37
+
38
+ def _quote(name, table=None, qualify=False):
39
+ from .builder import quote_ident
40
+
41
+ column = quote_ident(name)
42
+ return f"{quote_ident(table)}.{column}" if qualify and table is not None else column
43
+
44
+
45
+ class Comparison(Condition):
46
+ __slots__ = ("name", "operator", "value", "table")
47
+ _operators = {"=", "<>", "<", "<=", ">", ">="}
48
+
49
+ def __init__(self, name, operator, value, table=None):
50
+ if operator not in self._operators:
51
+ raise ValueError(f"Unsupported comparison operator: {operator!r}")
52
+ if value is None and operator not in ("=", "<>"):
53
+ raise ValueError("None supports only = and <> comparisons")
54
+ self.name = name
55
+ self.operator = operator
56
+ self.value = value
57
+ self.table = table
58
+
59
+ def render(self, qualify=False):
60
+ column = _quote(self.name, self.table, qualify)
61
+ if self.value is None:
62
+ suffix = "IS NULL" if self.operator == "=" else "IS NOT NULL"
63
+ return f"{column} {suffix}", ()
64
+ return f"{column} {self.operator} %s", (self.value,)
65
+
66
+ def columns(self):
67
+ return [(self.table, self.name)]
68
+
69
+
70
+ class InList(Condition):
71
+ __slots__ = ("name", "values", "table")
72
+
73
+ def __init__(self, name, values, table=None):
74
+ self.name = name
75
+ self.values = tuple(values)
76
+ self.table = table
77
+
78
+ def render(self, qualify=False):
79
+ column = _quote(self.name, self.table, qualify)
80
+ if not self.values:
81
+ return "FALSE", ()
82
+ return f"{column} = ANY(%s)", (list(self.values),)
83
+
84
+ def columns(self):
85
+ return [(self.table, self.name)]
86
+
87
+
88
+ class Pattern(Condition):
89
+ __slots__ = ("name", "operator", "pattern", "table")
90
+
91
+ def __init__(self, name, operator, pattern, table=None):
92
+ self.name = name
93
+ self.operator = operator
94
+ self.pattern = pattern
95
+ self.table = table
96
+
97
+ def render(self, qualify=False):
98
+ return f"{_quote(self.name, self.table, qualify)} {self.operator} %s", (self.pattern,)
99
+
100
+ def columns(self):
101
+ return [(self.table, self.name)]
102
+
103
+
104
+ class NullCheck(Condition):
105
+ __slots__ = ("name", "negated", "table")
106
+
107
+ def __init__(self, name, negated=False, table=None):
108
+ self.name = name
109
+ self.negated = negated
110
+ self.table = table
111
+
112
+ def render(self, qualify=False):
113
+ suffix = "IS NOT NULL" if self.negated else "IS NULL"
114
+ return f"{_quote(self.name, self.table, qualify)} {suffix}", ()
115
+
116
+ def columns(self):
117
+ return [(self.table, self.name)]
118
+
119
+
120
+ class And(Condition):
121
+ __slots__ = ("parts",)
122
+
123
+ def __init__(self, parts):
124
+ flattened = []
125
+ for part in parts:
126
+ flattened.extend(part.parts if isinstance(part, And) else (part,))
127
+ self.parts = tuple(flattened)
128
+
129
+ def render(self, qualify=False):
130
+ rendered = [part.render(qualify=qualify) for part in self.parts]
131
+ return "(" + " AND ".join(sql for sql, _ in rendered) + ")", tuple(
132
+ param for _, params in rendered for param in params
133
+ )
134
+
135
+ def columns(self):
136
+ return [column for part in self.parts for column in part.columns()]
137
+
138
+
139
+ class Or(Condition):
140
+ __slots__ = ("parts",)
141
+
142
+ def __init__(self, parts):
143
+ flattened = []
144
+ for part in parts:
145
+ flattened.extend(part.parts if isinstance(part, Or) else (part,))
146
+ self.parts = tuple(flattened)
147
+
148
+ def render(self, qualify=False):
149
+ rendered = [part.render(qualify=qualify) for part in self.parts]
150
+ return "(" + " OR ".join(sql for sql, _ in rendered) + ")", tuple(
151
+ param for _, params in rendered for param in params
152
+ )
153
+
154
+ def columns(self):
155
+ return [column for part in self.parts for column in part.columns()]
156
+
157
+
158
+ class Not(Condition):
159
+ __slots__ = ("condition",)
160
+
161
+ def __init__(self, condition):
162
+ self.condition = condition
163
+
164
+ def render(self, qualify=False):
165
+ sql, params = self.condition.render(qualify=qualify)
166
+ return f"NOT ({sql})", params
167
+
168
+ def columns(self):
169
+ return self.condition.columns()
170
+
171
+
172
+ class OrderBy(NamedTuple):
173
+ column: str
174
+ direction: str
175
+ table: str | None = None
176
+
177
+
178
+ def and_(*conditions):
179
+ if not conditions:
180
+ raise ValueError("and_() needs at least one condition")
181
+ if any(not isinstance(condition, Condition) for condition in conditions):
182
+ raise TypeError("and_() arguments must be conditions")
183
+ if len(conditions) == 1:
184
+ return conditions[0]
185
+ return And(conditions)
186
+
187
+
188
+ def or_(*conditions):
189
+ if not conditions:
190
+ raise ValueError("or_() needs at least one condition")
191
+ if any(not isinstance(condition, Condition) for condition in conditions):
192
+ raise TypeError("or_() arguments must be conditions")
193
+ if len(conditions) == 1:
194
+ return conditions[0]
195
+ return Or(conditions)
@@ -0,0 +1,9 @@
1
+ Metadata-Version: 2.4
2
+ Name: Pyzzel
3
+ Version: 0.1.1
4
+ Requires-Python: >=3.10
5
+ License-File: LICENSE
6
+ Requires-Dist: psycopg[binary,pool]>=3.2
7
+ Provides-Extra: dev
8
+ Requires-Dist: pytest; extra == "dev"
9
+ Dynamic: license-file
@@ -0,0 +1,24 @@
1
+ pyzzel/__init__.py,sha256=73ozXZo-aCsBVrJTAMS5tPo4v-HYqlAQaPzmmSSiOcQ,653
2
+ pyzzel/errors.py,sha256=2RfHR0OffSvwLaX-o02gp6iQu47PRltq90vywNb3guY,1439
3
+ pyzzel/pool.py,sha256=TznHlYLgUbPVQkC3QsTw5AjgqPjiLPElE9K5jGtXT0Y,2763
4
+ pyzzel/core/__init__.py,sha256=5Z2xEH8kejmHvq-OoFFf4Bnw1D3Yx0XQnrVSGB0lGB4,490
5
+ pyzzel/core/base.py,sha256=qj67tEbOQHYrWfVpTHBrkWd2Te2BDdOu9EKquTnapZE,18287
6
+ pyzzel/core/column.py,sha256=9ZP9RI4xRXRoE5Rn9Tpgz6DARhNv5FiU1ZkTtwrWVc4,7923
7
+ pyzzel/core/query.py,sha256=AF4nd8mXKf7IEx8Q98PjbaXsvNzEtwVedvhXJ-Dv2O8,16434
8
+ pyzzel/core/types.py,sha256=KJDs6I00nVS11ECOfhJB5k8pGNlIkjaZiPKKU3VMZzs,2361
9
+ pyzzel/migrate/__init__.py,sha256=BwEmZudcyOb4bA16sWTBi3AwkbX6ba8MTRZG352AFqQ,2123
10
+ pyzzel/migrate/__main__.py,sha256=CKo-nP4YcoMtfgFGaXRmu9F9kjIFwJL7uIgxM_KET7A,4988
11
+ pyzzel/migrate/apply.py,sha256=D6FXKezzVwhyZsZUzwVYNK7qqegqmihwCJbjjnQJ0Xg,6138
12
+ pyzzel/migrate/compare.py,sha256=B6ojTqUYPu3phwu6nvrAQ_AyO29cbOPB5clCLh9a7dY,2446
13
+ pyzzel/migrate/diff.py,sha256=5jqg-1cI-dGxJ9swl116bxY3lSn04hz0ZnYTZtxecFA,7197
14
+ pyzzel/migrate/introspect.py,sha256=_DjpcdBtkvZrManEVD8wkSnZgGmcNr-RDwx_4UR0V_Q,7105
15
+ pyzzel/migrate/schema.py,sha256=jiAVVRMARnxE0o0t08VOdzPPI4RY1CDJUMsrqHoqttk,5146
16
+ pyzzel/migrate/sqlgen.py,sha256=wM7t3mja2cMO2mur-0N0g1HxVcfw_3BUjvPo4UA2Cy8,4581
17
+ pyzzel/sql/__init__.py,sha256=LuRRqP0_kynLLBp4UtmhOfzLZnwau9Dvgk_IjMPY2Sc,863
18
+ pyzzel/sql/builder.py,sha256=OSvgclK_0uQOsGJcYQk9hpgnBt1O4g196Xv-7SpyZbM,13708
19
+ pyzzel/sql/conditions.py,sha256=e3vZ8ZxTwmXqRor50x68mx6A617FNCsQxhq8kRNKFTM,5950
20
+ pyzzel-0.1.1.dist-info/licenses/LICENSE,sha256=dGZqRAuRR0kTVzfxopGfZs9vy384fJ4pxDt58IWdebM,1072
21
+ pyzzel-0.1.1.dist-info/METADATA,sha256=M3YTErQxbXtlkZNSc4oimDYKAIoXtRbpf1hgEmhpFyU,217
22
+ pyzzel-0.1.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
23
+ pyzzel-0.1.1.dist-info/top_level.txt,sha256=6V1fdJQKQjlJmScjGqYg75sRTEKQyNS-dDwPQJ6-Sys,7
24
+ pyzzel-0.1.1.dist-info/RECORD,,
@@ -0,0 +1,5 @@
1
+ Wheel-Version: 1.0
2
+ Generator: setuptools (84.2.1)
3
+ Root-Is-Purelib: true
4
+ Tag: py3-none-any
5
+
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Himanshu Bokde
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
@@ -0,0 +1 @@
1
+ pyzzel