diff options
| author | Mike Bayer <mike_mp@zzzcomputing.com> | 2019-01-06 01:14:26 -0500 |
|---|---|---|
| committer | mike bayer <mike_mp@zzzcomputing.com> | 2019-01-06 17:34:50 +0000 |
| commit | 1e1a38e7801f410f244e4bbb44ec795ae152e04e (patch) | |
| tree | 28e725c5c8188bd0cfd133d1e268dbca9b524978 /lib/sqlalchemy/sql/schema.py | |
| parent | 404e69426b05a82d905cbb3ad33adafccddb00dd (diff) | |
| download | sqlalchemy-1e1a38e7801f410f244e4bbb44ec795ae152e04e.tar.gz | |
Run black -l 79 against all source files
This is a straight reformat run using black as is, with no edits
applied at all.
The black run will format code consistently, however in
some cases that are prevalent in SQLAlchemy code it produces
too-long lines. The too-long lines will be resolved in the
following commit that will resolve all remaining flake8 issues
including shadowed builtins, long lines, import order, unused
imports, duplicate imports, and docstring issues.
Change-Id: I7eda77fed3d8e73df84b3651fd6cfcfe858d4dc9
Diffstat (limited to 'lib/sqlalchemy/sql/schema.py')
| -rw-r--r-- | lib/sqlalchemy/sql/schema.py | 1129 |
1 files changed, 664 insertions, 465 deletions
diff --git a/lib/sqlalchemy/sql/schema.py b/lib/sqlalchemy/sql/schema.py index 3e9aa174a..d6c3f5000 100644 --- a/lib/sqlalchemy/sql/schema.py +++ b/lib/sqlalchemy/sql/schema.py @@ -36,25 +36,31 @@ import operator from . import visitors from . import type_api from .base import _bind_or_error, ColumnCollection -from .elements import ClauseElement, ColumnClause, \ - _as_truncated, TextClause, _literal_as_text,\ - ColumnElement, quoted_name +from .elements import ( + ClauseElement, + ColumnClause, + _as_truncated, + TextClause, + _literal_as_text, + ColumnElement, + quoted_name, +) from .selectable import TableClause import collections import sqlalchemy from . import ddl -RETAIN_SCHEMA = util.symbol('retain_schema') +RETAIN_SCHEMA = util.symbol("retain_schema") BLANK_SCHEMA = util.symbol( - 'blank_schema', + "blank_schema", """Symbol indicating that a :class:`.Table` or :class:`.Sequence` should have 'None' for its schema, even if the parent :class:`.MetaData` has specified a schema. .. versionadded:: 1.0.14 - """ + """, ) @@ -69,11 +75,15 @@ def _get_table_key(name, schema): # break an import cycle def _copy_expression(expression, source_table, target_table): def replace(col): - if isinstance(col, Column) and \ - col.table is source_table and col.key in source_table.c: + if ( + isinstance(col, Column) + and col.table is source_table + and col.key in source_table.c + ): return target_table.c[col.key] else: return None + return visitors.replacement_traverse(expression, {}, replace) @@ -81,7 +91,7 @@ def _copy_expression(expression, source_table, target_table): class SchemaItem(SchemaEventTarget, visitors.Visitable): """Base class for items that define a database schema.""" - __visit_name__ = 'schema_item' + __visit_name__ = "schema_item" def _init_items(self, *args): """Initialize the list of child items for this SchemaItem.""" @@ -95,10 +105,10 @@ class SchemaItem(SchemaEventTarget, visitors.Visitable): return [] def __repr__(self): - return util.generic_repr(self, omit_kwarg=['info']) + return util.generic_repr(self, omit_kwarg=["info"]) @property - @util.deprecated('0.9', 'Use ``<obj>.name.quote``') + @util.deprecated("0.9", "Use ``<obj>.name.quote``") def quote(self): """Return the value of the ``quote`` flag passed to this schema object, for those schema items which @@ -121,7 +131,7 @@ class SchemaItem(SchemaEventTarget, visitors.Visitable): return {} def _schema_item_copy(self, schema_item): - if 'info' in self.__dict__: + if "info" in self.__dict__: schema_item.info = self.info.copy() schema_item.dispatch._update(self.dispatch) return schema_item @@ -396,7 +406,7 @@ class Table(DialectKWArgs, SchemaItem, TableClause): """ - __visit_name__ = 'table' + __visit_name__ = "table" def __new__(cls, *args, **kw): if not args: @@ -408,26 +418,26 @@ class Table(DialectKWArgs, SchemaItem, TableClause): except IndexError: raise TypeError("Table() takes at least two arguments") - schema = kw.get('schema', None) + schema = kw.get("schema", None) if schema is None: schema = metadata.schema elif schema is BLANK_SCHEMA: schema = None - keep_existing = kw.pop('keep_existing', False) - extend_existing = kw.pop('extend_existing', False) - if 'useexisting' in kw: + keep_existing = kw.pop("keep_existing", False) + extend_existing = kw.pop("extend_existing", False) + if "useexisting" in kw: msg = "useexisting is deprecated. Use extend_existing." util.warn_deprecated(msg) if extend_existing: msg = "useexisting is synonymous with extend_existing." raise exc.ArgumentError(msg) - extend_existing = kw.pop('useexisting', False) + extend_existing = kw.pop("useexisting", False) if keep_existing and extend_existing: msg = "keep_existing and extend_existing are mutually exclusive." raise exc.ArgumentError(msg) - mustexist = kw.pop('mustexist', False) + mustexist = kw.pop("mustexist", False) key = _get_table_key(name, schema) if key in metadata.tables: if not keep_existing and not extend_existing and bool(args): @@ -436,15 +446,15 @@ class Table(DialectKWArgs, SchemaItem, TableClause): "instance. Specify 'extend_existing=True' " "to redefine " "options and columns on an " - "existing Table object." % key) + "existing Table object." % key + ) table = metadata.tables[key] if extend_existing: table._init_existing(*args, **kw) return table else: if mustexist: - raise exc.InvalidRequestError( - "Table '%s' not defined" % (key)) + raise exc.InvalidRequestError("Table '%s' not defined" % (key)) table = object.__new__(cls) table.dispatch.before_parent_attach(table, metadata) metadata._add_table(name, schema, table) @@ -457,7 +467,7 @@ class Table(DialectKWArgs, SchemaItem, TableClause): metadata._remove_table(name, schema) @property - @util.deprecated('0.9', 'Use ``table.schema.quote``') + @util.deprecated("0.9", "Use ``table.schema.quote``") def quote_schema(self): """Return the value of the ``quote_schema`` flag passed to this :class:`.Table`. @@ -478,23 +488,25 @@ class Table(DialectKWArgs, SchemaItem, TableClause): def _init(self, name, metadata, *args, **kwargs): super(Table, self).__init__( - quoted_name(name, kwargs.pop('quote', None))) + quoted_name(name, kwargs.pop("quote", None)) + ) self.metadata = metadata - self.schema = kwargs.pop('schema', None) + self.schema = kwargs.pop("schema", None) if self.schema is None: self.schema = metadata.schema elif self.schema is BLANK_SCHEMA: self.schema = None else: - quote_schema = kwargs.pop('quote_schema', None) + quote_schema = kwargs.pop("quote_schema", None) self.schema = quoted_name(self.schema, quote_schema) self.indexes = set() self.constraints = set() self._columns = ColumnCollection() - PrimaryKeyConstraint(_implicit_generated=True).\ - _set_parent_with_dispatch(self) + PrimaryKeyConstraint( + _implicit_generated=True + )._set_parent_with_dispatch(self) self.foreign_keys = set() self._extra_dependencies = set() if self.schema is not None: @@ -502,26 +514,26 @@ class Table(DialectKWArgs, SchemaItem, TableClause): else: self.fullname = self.name - autoload_with = kwargs.pop('autoload_with', None) - autoload = kwargs.pop('autoload', autoload_with is not None) + autoload_with = kwargs.pop("autoload_with", None) + autoload = kwargs.pop("autoload", autoload_with is not None) # this argument is only used with _init_existing() - kwargs.pop('autoload_replace', True) + kwargs.pop("autoload_replace", True) _extend_on = kwargs.pop("_extend_on", None) - include_columns = kwargs.pop('include_columns', None) + include_columns = kwargs.pop("include_columns", None) - self.implicit_returning = kwargs.pop('implicit_returning', True) + self.implicit_returning = kwargs.pop("implicit_returning", True) - self.comment = kwargs.pop('comment', None) + self.comment = kwargs.pop("comment", None) - if 'info' in kwargs: - self.info = kwargs.pop('info') - if 'listeners' in kwargs: - listeners = kwargs.pop('listeners') + if "info" in kwargs: + self.info = kwargs.pop("info") + if "listeners" in kwargs: + listeners = kwargs.pop("listeners") for evt, fn in listeners: event.listen(self, evt, fn) - self._prefixes = kwargs.pop('prefixes', []) + self._prefixes = kwargs.pop("prefixes", []) self._extra_kwargs(**kwargs) @@ -530,21 +542,29 @@ class Table(DialectKWArgs, SchemaItem, TableClause): # circular foreign keys if autoload: self._autoload( - metadata, autoload_with, - include_columns, _extend_on=_extend_on) + metadata, autoload_with, include_columns, _extend_on=_extend_on + ) # initialize all the column, etc. objects. done after reflection to # allow user-overrides self._init_items(*args) - def _autoload(self, metadata, autoload_with, include_columns, - exclude_columns=(), _extend_on=None): + def _autoload( + self, + metadata, + autoload_with, + include_columns, + exclude_columns=(), + _extend_on=None, + ): if autoload_with: autoload_with.run_callable( autoload_with.dialect.reflecttable, - self, include_columns, exclude_columns, - _extend_on=_extend_on + self, + include_columns, + exclude_columns, + _extend_on=_extend_on, ) else: bind = _bind_or_error( @@ -553,11 +573,14 @@ class Table(DialectKWArgs, SchemaItem, TableClause): "Pass an engine to the Table via " "autoload_with=<someengine>, " "or associate the MetaData with an engine via " - "metadata.bind=<someengine>") + "metadata.bind=<someengine>", + ) bind.run_callable( bind.dialect.reflecttable, - self, include_columns, exclude_columns, - _extend_on=_extend_on + self, + include_columns, + exclude_columns, + _extend_on=_extend_on, ) @property @@ -582,34 +605,36 @@ class Table(DialectKWArgs, SchemaItem, TableClause): return set(fkc.constraint for fkc in self.foreign_keys) def _init_existing(self, *args, **kwargs): - autoload_with = kwargs.pop('autoload_with', None) - autoload = kwargs.pop('autoload', autoload_with is not None) - autoload_replace = kwargs.pop('autoload_replace', True) - schema = kwargs.pop('schema', None) - _extend_on = kwargs.pop('_extend_on', None) + autoload_with = kwargs.pop("autoload_with", None) + autoload = kwargs.pop("autoload", autoload_with is not None) + autoload_replace = kwargs.pop("autoload_replace", True) + schema = kwargs.pop("schema", None) + _extend_on = kwargs.pop("_extend_on", None) if schema and schema != self.schema: raise exc.ArgumentError( "Can't change schema of existing table from '%s' to '%s'", - (self.schema, schema)) + (self.schema, schema), + ) - include_columns = kwargs.pop('include_columns', None) + include_columns = kwargs.pop("include_columns", None) if include_columns is not None: for c in self.c: if c.name not in include_columns: self._columns.remove(c) - for key in ('quote', 'quote_schema'): + for key in ("quote", "quote_schema"): if key in kwargs: raise exc.ArgumentError( - "Can't redefine 'quote' or 'quote_schema' arguments") + "Can't redefine 'quote' or 'quote_schema' arguments" + ) - if 'comment' in kwargs: - self.comment = kwargs.pop('comment', None) + if "comment" in kwargs: + self.comment = kwargs.pop("comment", None) - if 'info' in kwargs: - self.info = kwargs.pop('info') + if "info" in kwargs: + self.info = kwargs.pop("info") if autoload: if not autoload_replace: @@ -620,8 +645,12 @@ class Table(DialectKWArgs, SchemaItem, TableClause): else: exclude_columns = () self._autoload( - self.metadata, autoload_with, - include_columns, exclude_columns, _extend_on=_extend_on) + self.metadata, + autoload_with, + include_columns, + exclude_columns, + _extend_on=_extend_on, + ) self._extra_kwargs(**kwargs) self._init_items(*args) @@ -653,10 +682,12 @@ class Table(DialectKWArgs, SchemaItem, TableClause): return _get_table_key(self.name, self.schema) def __repr__(self): - return "Table(%s)" % ', '.join( - [repr(self.name)] + [repr(self.metadata)] + - [repr(x) for x in self.columns] + - ["%s=%s" % (k, repr(getattr(self, k))) for k in ['schema']]) + return "Table(%s)" % ", ".join( + [repr(self.name)] + + [repr(self.metadata)] + + [repr(x) for x in self.columns] + + ["%s=%s" % (k, repr(getattr(self, k))) for k in ["schema"]] + ) def __str__(self): return _get_table_key(self.description, self.schema) @@ -735,17 +766,19 @@ class Table(DialectKWArgs, SchemaItem, TableClause): def adapt_listener(target, connection, **kw): listener(event_name, target, connection) - event.listen(self, "" + event_name.replace('-', '_'), adapt_listener) + event.listen(self, "" + event_name.replace("-", "_"), adapt_listener) def _set_parent(self, metadata): metadata._add_table(self.name, self.schema, self) self.metadata = metadata - def get_children(self, column_collections=True, - schema_visitor=False, **kw): + def get_children( + self, column_collections=True, schema_visitor=False, **kw + ): if not schema_visitor: return TableClause.get_children( - self, column_collections=column_collections, **kw) + self, column_collections=column_collections, **kw + ) else: if column_collections: return list(self.columns) @@ -758,8 +791,9 @@ class Table(DialectKWArgs, SchemaItem, TableClause): if bind is None: bind = _bind_or_error(self) - return bind.run_callable(bind.dialect.has_table, - self.name, schema=self.schema) + return bind.run_callable( + bind.dialect.has_table, self.name, schema=self.schema + ) def create(self, bind=None, checkfirst=False): """Issue a ``CREATE`` statement for this @@ -774,9 +808,7 @@ class Table(DialectKWArgs, SchemaItem, TableClause): if bind is None: bind = _bind_or_error(self) - bind._run_visitor(ddl.SchemaGenerator, - self, - checkfirst=checkfirst) + bind._run_visitor(ddl.SchemaGenerator, self, checkfirst=checkfirst) def drop(self, bind=None, checkfirst=False): """Issue a ``DROP`` statement for this @@ -790,12 +822,15 @@ class Table(DialectKWArgs, SchemaItem, TableClause): """ if bind is None: bind = _bind_or_error(self) - bind._run_visitor(ddl.SchemaDropper, - self, - checkfirst=checkfirst) - - def tometadata(self, metadata, schema=RETAIN_SCHEMA, - referred_schema_fn=None, name=None): + bind._run_visitor(ddl.SchemaDropper, self, checkfirst=checkfirst) + + def tometadata( + self, + metadata, + schema=RETAIN_SCHEMA, + referred_schema_fn=None, + name=None, + ): """Return a copy of this :class:`.Table` associated with a different :class:`.MetaData`. @@ -868,29 +903,37 @@ class Table(DialectKWArgs, SchemaItem, TableClause): schema = metadata.schema key = _get_table_key(name, schema) if key in metadata.tables: - util.warn("Table '%s' already exists within the given " - "MetaData - not copying." % self.description) + util.warn( + "Table '%s' already exists within the given " + "MetaData - not copying." % self.description + ) return metadata.tables[key] args = [] for c in self.columns: args.append(c.copy(schema=schema)) table = Table( - name, metadata, schema=schema, + name, + metadata, + schema=schema, comment=self.comment, - *args, **self.kwargs + *args, + **self.kwargs ) for c in self.constraints: if isinstance(c, ForeignKeyConstraint): referred_schema = c._referred_schema if referred_schema_fn: fk_constraint_schema = referred_schema_fn( - self, schema, c, referred_schema) + self, schema, c, referred_schema + ) else: fk_constraint_schema = ( - schema if referred_schema == self.schema else None) + schema if referred_schema == self.schema else None + ) table.append_constraint( - c.copy(schema=fk_constraint_schema, target_table=table)) + c.copy(schema=fk_constraint_schema, target_table=table) + ) elif not c._type_bound: # skip unique constraints that would be generated # by the 'unique' flag on Column @@ -898,25 +941,30 @@ class Table(DialectKWArgs, SchemaItem, TableClause): continue table.append_constraint( - c.copy(schema=schema, target_table=table)) + c.copy(schema=schema, target_table=table) + ) for index in self.indexes: # skip indexes that would be generated # by the 'index' flag on Column if index._column_flag: continue - Index(index.name, - unique=index.unique, - *[_copy_expression(expr, self, table) - for expr in index.expressions], - _table=table, - **index.kwargs) + Index( + index.name, + unique=index.unique, + *[ + _copy_expression(expr, self, table) + for expr in index.expressions + ], + _table=table, + **index.kwargs + ) return self._schema_item_copy(table) class Column(DialectKWArgs, SchemaItem, ColumnClause): """Represents a column in a database table.""" - __visit_name__ = 'column' + __visit_name__ = "column" def __init__(self, *args, **kwargs): r""" @@ -1192,14 +1240,15 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): """ - name = kwargs.pop('name', None) - type_ = kwargs.pop('type_', None) + name = kwargs.pop("name", None) + type_ = kwargs.pop("type_", None) args = list(args) if args: if isinstance(args[0], util.string_types): if name is not None: raise exc.ArgumentError( - "May not pass name positionally and as a keyword.") + "May not pass name positionally and as a keyword." + ) name = args.pop(0) if args: coltype = args[0] @@ -1207,40 +1256,42 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): if hasattr(coltype, "_sqla_type"): if type_ is not None: raise exc.ArgumentError( - "May not pass type_ positionally and as a keyword.") + "May not pass type_ positionally and as a keyword." + ) type_ = args.pop(0) if name is not None: - name = quoted_name(name, kwargs.pop('quote', None)) + name = quoted_name(name, kwargs.pop("quote", None)) elif "quote" in kwargs: - raise exc.ArgumentError("Explicit 'name' is required when " - "sending 'quote' argument") + raise exc.ArgumentError( + "Explicit 'name' is required when " "sending 'quote' argument" + ) super(Column, self).__init__(name, type_) - self.key = kwargs.pop('key', name) - self.primary_key = kwargs.pop('primary_key', False) - self.nullable = kwargs.pop('nullable', not self.primary_key) - self.default = kwargs.pop('default', None) - self.server_default = kwargs.pop('server_default', None) - self.server_onupdate = kwargs.pop('server_onupdate', None) + self.key = kwargs.pop("key", name) + self.primary_key = kwargs.pop("primary_key", False) + self.nullable = kwargs.pop("nullable", not self.primary_key) + self.default = kwargs.pop("default", None) + self.server_default = kwargs.pop("server_default", None) + self.server_onupdate = kwargs.pop("server_onupdate", None) # these default to None because .index and .unique is *not* # an informational flag about Column - there can still be an # Index or UniqueConstraint referring to this Column. - self.index = kwargs.pop('index', None) - self.unique = kwargs.pop('unique', None) + self.index = kwargs.pop("index", None) + self.unique = kwargs.pop("unique", None) - self.system = kwargs.pop('system', False) - self.doc = kwargs.pop('doc', None) - self.onupdate = kwargs.pop('onupdate', None) - self.autoincrement = kwargs.pop('autoincrement', "auto") + self.system = kwargs.pop("system", False) + self.doc = kwargs.pop("doc", None) + self.onupdate = kwargs.pop("onupdate", None) + self.autoincrement = kwargs.pop("autoincrement", "auto") self.constraints = set() self.foreign_keys = set() - self.comment = kwargs.pop('comment', None) + self.comment = kwargs.pop("comment", None) # check if this Column is proxying another column - if '_proxies' in kwargs: - self._proxies = kwargs.pop('_proxies') + if "_proxies" in kwargs: + self._proxies = kwargs.pop("_proxies") # otherwise, add DDL-related events elif isinstance(self.type, SchemaEventTarget): self.type._set_parent_with_dispatch(self) @@ -1249,14 +1300,13 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): if isinstance(self.default, (ColumnDefault, Sequence)): args.append(self.default) else: - if getattr(self.type, '_warn_on_bytestring', False): + if getattr(self.type, "_warn_on_bytestring", False): if isinstance(self.default, util.binary_type): util.warn( "Unicode column '%s' has non-unicode " - "default value %r specified." % ( - self.key, - self.default - )) + "default value %r specified." + % (self.key, self.default) + ) args.append(ColumnDefault(self.default)) if self.server_default is not None: @@ -1275,30 +1325,31 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): if isinstance(self.server_onupdate, FetchedValue): args.append(self.server_onupdate._as_for_update(True)) else: - args.append(DefaultClause(self.server_onupdate, - for_update=True)) + args.append( + DefaultClause(self.server_onupdate, for_update=True) + ) self._init_items(*args) util.set_creation_order(self) - if 'info' in kwargs: - self.info = kwargs.pop('info') + if "info" in kwargs: + self.info = kwargs.pop("info") self._extra_kwargs(**kwargs) def _extra_kwargs(self, **kwargs): self._validate_dialect_kwargs(kwargs) -# @property -# def quote(self): -# return getattr(self.name, "quote", None) + # @property + # def quote(self): + # return getattr(self.name, "quote", None) def __str__(self): if self.name is None: return "(no name)" elif self.table is not None: if self.table.named_with_column: - return (self.table.description + "." + self.description) + return self.table.description + "." + self.description else: return self.description else: @@ -1320,40 +1371,47 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): def __repr__(self): kwarg = [] if self.key != self.name: - kwarg.append('key') + kwarg.append("key") if self.primary_key: - kwarg.append('primary_key') + kwarg.append("primary_key") if not self.nullable: - kwarg.append('nullable') + kwarg.append("nullable") if self.onupdate: - kwarg.append('onupdate') + kwarg.append("onupdate") if self.default: - kwarg.append('default') + kwarg.append("default") if self.server_default: - kwarg.append('server_default') - return "Column(%s)" % ', '.join( - [repr(self.name)] + [repr(self.type)] + - [repr(x) for x in self.foreign_keys if x is not None] + - [repr(x) for x in self.constraints] + - [(self.table is not None and "table=<%s>" % - self.table.description or "table=None")] + - ["%s=%s" % (k, repr(getattr(self, k))) for k in kwarg]) + kwarg.append("server_default") + return "Column(%s)" % ", ".join( + [repr(self.name)] + + [repr(self.type)] + + [repr(x) for x in self.foreign_keys if x is not None] + + [repr(x) for x in self.constraints] + + [ + ( + self.table is not None + and "table=<%s>" % self.table.description + or "table=None" + ) + ] + + ["%s=%s" % (k, repr(getattr(self, k))) for k in kwarg] + ) def _set_parent(self, table): if not self.name: raise exc.ArgumentError( "Column must be constructed with a non-blank name or " - "assign a non-blank .name before adding to a Table.") + "assign a non-blank .name before adding to a Table." + ) if self.key is None: self.key = self.name - existing = getattr(self, 'table', None) + existing = getattr(self, "table", None) if existing is not None and existing is not table: raise exc.ArgumentError( - "Column object '%s' already assigned to Table '%s'" % ( - self.key, - existing.description - )) + "Column object '%s' already assigned to Table '%s'" + % (self.key, existing.description) + ) if self.key in table._columns: col = table._columns.get(self.key) @@ -1373,8 +1431,9 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): elif self.key in table.primary_key: raise exc.ArgumentError( "Trying to redefine primary-key column '%s' as a " - "non-primary-key column on table '%s'" % ( - self.key, table.fullname)) + "non-primary-key column on table '%s'" + % (self.key, table.fullname) + ) self.table = table @@ -1383,7 +1442,8 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): raise exc.ArgumentError( "The 'index' keyword argument on Column is boolean only. " "To create indexes with a specific name, create an " - "explicit Index object external to the Table.") + "explicit Index object external to the Table." + ) Index(None, self, unique=bool(self.unique), _column_flag=True) elif self.unique: if isinstance(self.unique, util.string_types): @@ -1392,9 +1452,11 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): "only. To create unique constraints or indexes with a " "specific name, append an explicit UniqueConstraint to " "the Table's list of elements, or create an explicit " - "Index object external to the Table.") + "Index object external to the Table." + ) table.append_constraint( - UniqueConstraint(self.key, _column_flag=True)) + UniqueConstraint(self.key, _column_flag=True) + ) self._setup_on_memoized_fks(lambda fk: fk._set_remote_table(table)) @@ -1413,7 +1475,7 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): if self.table is not None: fn(self, self.table) else: - event.listen(self, 'after_parent_attach', fn) + event.listen(self, "after_parent_attach", fn) def copy(self, **kw): """Create a copy of this ``Column``, unitialized. @@ -1423,9 +1485,9 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): """ # Constraint objects plus non-constraint-bound ForeignKey objects - args = \ - [c.copy(**kw) for c in self.constraints if not c._type_bound] + \ - [c.copy(**kw) for c in self.foreign_keys if not c.constraint] + args = [ + c.copy(**kw) for c in self.constraints if not c._type_bound + ] + [c.copy(**kw) for c in self.foreign_keys if not c.constraint] type_ = self.type if isinstance(type_, SchemaEventTarget): @@ -1452,8 +1514,9 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): ) return self._schema_item_copy(c) - def _make_proxy(self, selectable, name=None, key=None, - name_is_truncatable=False, **kw): + def _make_proxy( + self, selectable, name=None, key=None, name_is_truncatable=False, **kw + ): """Create a *proxy* for this column. This is a copy of this ``Column`` referenced by a different parent @@ -1462,22 +1525,28 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): information is not transferred. """ - fk = [ForeignKey(f.column, _constraint=f.constraint) - for f in self.foreign_keys] + fk = [ + ForeignKey(f.column, _constraint=f.constraint) + for f in self.foreign_keys + ] if name is None and self.name is None: raise exc.InvalidRequestError( "Cannot initialize a sub-selectable" " with this Column object until its 'name' has " - "been assigned.") + "been assigned." + ) try: c = self._constructor( - _as_truncated(name or self.name) if - name_is_truncatable else (name or self.name), + _as_truncated(name or self.name) + if name_is_truncatable + else (name or self.name), self.type, key=key if key else name if name else self.key, primary_key=self.primary_key, nullable=self.nullable, - _proxies=[self], *fk) + _proxies=[self], + *fk + ) except TypeError: util.raise_from_cause( TypeError( @@ -1485,7 +1554,8 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): "Ensure the class includes a _constructor() " "attribute or method which accepts the " "standard Column constructor arguments, or " - "references the Column class itself." % self.__class__) + "references the Column class itself." % self.__class__ + ) ) c.table = selectable @@ -1499,9 +1569,11 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): def get_children(self, schema_visitor=False, **kwargs): if schema_visitor: - return [x for x in (self.default, self.onupdate) - if x is not None] + \ - list(self.foreign_keys) + list(self.constraints) + return ( + [x for x in (self.default, self.onupdate) if x is not None] + + list(self.foreign_keys) + + list(self.constraints) + ) else: return ColumnClause.get_children(self, **kwargs) @@ -1543,13 +1615,23 @@ class ForeignKey(DialectKWArgs, SchemaItem): """ - __visit_name__ = 'foreign_key' - - def __init__(self, column, _constraint=None, use_alter=False, name=None, - onupdate=None, ondelete=None, deferrable=None, - initially=None, link_to_name=False, match=None, - info=None, - **dialect_kw): + __visit_name__ = "foreign_key" + + def __init__( + self, + column, + _constraint=None, + use_alter=False, + name=None, + onupdate=None, + ondelete=None, + deferrable=None, + initially=None, + link_to_name=False, + match=None, + info=None, + **dialect_kw + ): r""" Construct a column-level FOREIGN KEY. @@ -1626,7 +1708,7 @@ class ForeignKey(DialectKWArgs, SchemaItem): if isinstance(self._colspec, util.string_types): self._table_column = None else: - if hasattr(self._colspec, '__clause_element__'): + if hasattr(self._colspec, "__clause_element__"): self._table_column = self._colspec.__clause_element__() else: self._table_column = self._colspec @@ -1634,9 +1716,11 @@ class ForeignKey(DialectKWArgs, SchemaItem): if not isinstance(self._table_column, ColumnClause): raise exc.ArgumentError( "String, Column, or Column-bound argument " - "expected, got %r" % self._table_column) + "expected, got %r" % self._table_column + ) elif not isinstance( - self._table_column.table, (util.NoneType, TableClause)): + self._table_column.table, (util.NoneType, TableClause) + ): raise exc.ArgumentError( "ForeignKey received Column not bound " "to a Table, got: %r" % self._table_column.table @@ -1715,7 +1799,9 @@ class ForeignKey(DialectKWArgs, SchemaItem): return "%s.%s" % (table_name, colname) elif self._table_column is not None: return "%s.%s" % ( - self._table_column.table.fullname, self._table_column.key) + self._table_column.table.fullname, + self._table_column.key, + ) else: return self._colspec @@ -1756,12 +1842,12 @@ class ForeignKey(DialectKWArgs, SchemaItem): def _column_tokens(self): """parse a string-based _colspec into its component parts.""" - m = self._get_colspec().split('.') + m = self._get_colspec().split(".") if m is None: raise exc.ArgumentError( - "Invalid foreign key column specification: %s" % - self._colspec) - if (len(m) == 1): + "Invalid foreign key column specification: %s" % self._colspec + ) + if len(m) == 1: tname = m.pop() colname = None else: @@ -1777,8 +1863,8 @@ class ForeignKey(DialectKWArgs, SchemaItem): # indirectly related -- Ticket #594. This assumes that '.' # will never appear *within* any component of the FK. - if (len(m) > 0): - schema = '.'.join(m) + if len(m) > 0: + schema = ".".join(m) else: schema = None return schema, tname, colname @@ -1787,12 +1873,14 @@ class ForeignKey(DialectKWArgs, SchemaItem): if self.parent is None: raise exc.InvalidRequestError( "this ForeignKey object does not yet have a " - "parent Column associated with it.") + "parent Column associated with it." + ) elif self.parent.table is None: raise exc.InvalidRequestError( "this ForeignKey's parent column is not yet associated " - "with a Table.") + "with a Table." + ) parenttable = self.parent.table @@ -1817,7 +1905,7 @@ class ForeignKey(DialectKWArgs, SchemaItem): return parenttable, tablekey, colname def _link_to_col_by_colstring(self, parenttable, table, colname): - if not hasattr(self.constraint, '_referred_table'): + if not hasattr(self.constraint, "_referred_table"): self.constraint._referred_table = table else: assert self.constraint._referred_table is table @@ -1843,9 +1931,11 @@ class ForeignKey(DialectKWArgs, SchemaItem): raise exc.NoReferencedColumnError( "Could not initialize target column " "for ForeignKey '%s' on table '%s': " - "table '%s' has no column named '%s'" % - (self._colspec, parenttable.name, table.name, key), - table.name, key) + "table '%s' has no column named '%s'" + % (self._colspec, parenttable.name, table.name, key), + table.name, + key, + ) self._set_target_column(_column) @@ -1861,6 +1951,7 @@ class ForeignKey(DialectKWArgs, SchemaItem): def set_type(fk): if fk.parent.type._isnull: fk.parent.type = column.type + self.parent._setup_on_memoized_fks(set_type) self.column = column @@ -1888,21 +1979,25 @@ class ForeignKey(DialectKWArgs, SchemaItem): raise exc.NoReferencedTableError( "Foreign key associated with column '%s' could not find " "table '%s' with which to generate a " - "foreign key to target column '%s'" % - (self.parent, tablekey, colname), - tablekey) + "foreign key to target column '%s'" + % (self.parent, tablekey, colname), + tablekey, + ) elif parenttable.key not in parenttable.metadata: raise exc.InvalidRequestError( "Table %s is no longer associated with its " - "parent MetaData" % parenttable) + "parent MetaData" % parenttable + ) else: raise exc.NoReferencedColumnError( "Could not initialize target column for " "ForeignKey '%s' on table '%s': " - "table '%s' has no column named '%s'" % ( - self._colspec, parenttable.name, tablekey, colname), - tablekey, colname) - elif hasattr(self._colspec, '__clause_element__'): + "table '%s' has no column named '%s'" + % (self._colspec, parenttable.name, tablekey, colname), + tablekey, + colname, + ) + elif hasattr(self._colspec, "__clause_element__"): _column = self._colspec.__clause_element__() return _column else: @@ -1912,7 +2007,8 @@ class ForeignKey(DialectKWArgs, SchemaItem): def _set_parent(self, column): if self.parent is not None and self.parent is not column: raise exc.InvalidRequestError( - "This ForeignKey already has a parent !") + "This ForeignKey already has a parent !" + ) self.parent = column self.parent.foreign_keys.add(self) self.parent._on_table_attach(self._set_table) @@ -1935,9 +2031,14 @@ class ForeignKey(DialectKWArgs, SchemaItem): # on the hosting Table when attached to the Table. if self.constraint is None and isinstance(table, Table): self.constraint = ForeignKeyConstraint( - [], [], use_alter=self.use_alter, name=self.name, - onupdate=self.onupdate, ondelete=self.ondelete, - deferrable=self.deferrable, initially=self.initially, + [], + [], + use_alter=self.use_alter, + name=self.name, + onupdate=self.onupdate, + ondelete=self.ondelete, + deferrable=self.deferrable, + initially=self.initially, match=self.match, **self._unvalidated_dialect_kw ) @@ -1953,13 +2054,12 @@ class ForeignKey(DialectKWArgs, SchemaItem): if table_key in parenttable.metadata.tables: table = parenttable.metadata.tables[table_key] try: - self._link_to_col_by_colstring( - parenttable, table, colname) + self._link_to_col_by_colstring(parenttable, table, colname) except exc.NoReferencedColumnError: # this is OK, we'll try later pass parenttable.metadata._fk_memos[fk_key].append(self) - elif hasattr(self._colspec, '__clause_element__'): + elif hasattr(self._colspec, "__clause_element__"): _column = self._colspec.__clause_element__() self._set_target_column(_column) else: @@ -1971,7 +2071,8 @@ class _NotAColumnExpr(object): def _not_a_column_expr(self): raise exc.InvalidRequestError( "This %s cannot be used directly " - "as a column expression." % self.__class__.__name__) + "as a column expression." % self.__class__.__name__ + ) __clause_element__ = self_group = lambda self: self._not_a_column_expr() _from_objects = property(lambda self: self._not_a_column_expr()) @@ -1980,7 +2081,7 @@ class _NotAColumnExpr(object): class DefaultGenerator(_NotAColumnExpr, SchemaItem): """Base class for column *default* values.""" - __visit_name__ = 'default_generator' + __visit_name__ = "default_generator" is_sequence = False is_server_default = False @@ -2007,7 +2108,7 @@ class DefaultGenerator(_NotAColumnExpr, SchemaItem): @property def bind(self): """Return the connectable associated with this default.""" - if getattr(self, 'column', None) is not None: + if getattr(self, "column", None) is not None: return self.column.table.bind else: return None @@ -2064,7 +2165,8 @@ class ColumnDefault(DefaultGenerator): super(ColumnDefault, self).__init__(**kwargs) if isinstance(arg, FetchedValue): raise exc.ArgumentError( - "ColumnDefault may not be a server-side default type.") + "ColumnDefault may not be a server-side default type." + ) if util.callable(arg): arg = self._maybe_wrap_callable(arg) self.arg = arg @@ -2079,9 +2181,11 @@ class ColumnDefault(DefaultGenerator): @util.memoized_property def is_scalar(self): - return not self.is_callable and \ - not self.is_clause_element and \ - not self.is_sequence + return ( + not self.is_callable + and not self.is_clause_element + and not self.is_sequence + ) @util.memoized_property @util.dependencies("sqlalchemy.sql.sqltypes") @@ -2114,17 +2218,19 @@ class ColumnDefault(DefaultGenerator): else: raise exc.ArgumentError( "ColumnDefault Python function takes zero or one " - "positional arguments") + "positional arguments" + ) def _visit_name(self): if self.for_update: return "column_onupdate" else: return "column_default" + __visit_name__ = property(_visit_name) def __repr__(self): - return "ColumnDefault(%r)" % (self.arg, ) + return "ColumnDefault(%r)" % (self.arg,) class Sequence(DefaultGenerator): @@ -2157,15 +2263,29 @@ class Sequence(DefaultGenerator): """ - __visit_name__ = 'sequence' + __visit_name__ = "sequence" is_sequence = True - def __init__(self, name, start=None, increment=None, minvalue=None, - maxvalue=None, nominvalue=None, nomaxvalue=None, cycle=None, - schema=None, cache=None, order=None, optional=False, - quote=None, metadata=None, quote_schema=None, - for_update=False): + def __init__( + self, + name, + start=None, + increment=None, + minvalue=None, + maxvalue=None, + nominvalue=None, + nomaxvalue=None, + cycle=None, + schema=None, + cache=None, + order=None, + optional=False, + quote=None, + metadata=None, + quote_schema=None, + for_update=False, + ): """Construct a :class:`.Sequence` object. :param name: The name of the sequence. @@ -2353,27 +2473,22 @@ class Sequence(DefaultGenerator): if bind is None: bind = _bind_or_error(self) - bind._run_visitor(ddl.SchemaGenerator, - self, - checkfirst=checkfirst) + bind._run_visitor(ddl.SchemaGenerator, self, checkfirst=checkfirst) def drop(self, bind=None, checkfirst=True): """Drops this sequence from the database.""" if bind is None: bind = _bind_or_error(self) - bind._run_visitor(ddl.SchemaDropper, - self, - checkfirst=checkfirst) + bind._run_visitor(ddl.SchemaDropper, self, checkfirst=checkfirst) def _not_a_column_expr(self): raise exc.InvalidRequestError( "This %s cannot be used directly " "as a column expression. Use func.next_value(sequence) " "to produce a 'next value' function that's usable " - "as a column element." - % self.__class__.__name__) - + "as a column element." % self.__class__.__name__ + ) @inspection._self_inspects @@ -2396,6 +2511,7 @@ class FetchedValue(_NotAColumnExpr, SchemaEventTarget): :ref:`triggered_columns` """ + is_server_default = True reflected = False has_argument = False @@ -2412,7 +2528,7 @@ class FetchedValue(_NotAColumnExpr, SchemaEventTarget): def _clone(self, for_update): n = self.__class__.__new__(self.__class__) n.__dict__.update(self.__dict__) - n.__dict__.pop('column', None) + n.__dict__.pop("column", None) n.for_update = for_update return n @@ -2452,16 +2568,15 @@ class DefaultClause(FetchedValue): has_argument = True def __init__(self, arg, for_update=False, _reflected=False): - util.assert_arg_type(arg, (util.string_types[0], - ClauseElement, - TextClause), 'arg') + util.assert_arg_type( + arg, (util.string_types[0], ClauseElement, TextClause), "arg" + ) super(DefaultClause, self).__init__(for_update) self.arg = arg self.reflected = _reflected def __repr__(self): - return "DefaultClause(%r, for_update=%r)" % \ - (self.arg, self.for_update) + return "DefaultClause(%r, for_update=%r)" % (self.arg, self.for_update) class PassiveDefault(DefaultClause): @@ -2471,10 +2586,13 @@ class PassiveDefault(DefaultClause): :class:`.PassiveDefault` is deprecated. Use :class:`.DefaultClause`. """ - @util.deprecated("0.6", - ":class:`.PassiveDefault` is deprecated. " - "Use :class:`.DefaultClause`.", - False) + + @util.deprecated( + "0.6", + ":class:`.PassiveDefault` is deprecated. " + "Use :class:`.DefaultClause`.", + False, + ) def __init__(self, *arg, **kw): DefaultClause.__init__(self, *arg, **kw) @@ -2482,11 +2600,18 @@ class PassiveDefault(DefaultClause): class Constraint(DialectKWArgs, SchemaItem): """A table-level SQL constraint.""" - __visit_name__ = 'constraint' - - def __init__(self, name=None, deferrable=None, initially=None, - _create_rule=None, info=None, _type_bound=False, - **dialect_kw): + __visit_name__ = "constraint" + + def __init__( + self, + name=None, + deferrable=None, + initially=None, + _create_rule=None, + info=None, + _type_bound=False, + **dialect_kw + ): r"""Create a SQL constraint. :param name: @@ -2548,7 +2673,8 @@ class Constraint(DialectKWArgs, SchemaItem): pass raise exc.InvalidRequestError( "This constraint is not bound to a table. Did you " - "mean to call table.append_constraint(constraint) ?") + "mean to call table.append_constraint(constraint) ?" + ) def _set_parent(self, parent): self.parent = parent @@ -2559,7 +2685,7 @@ class Constraint(DialectKWArgs, SchemaItem): def _to_schema_column(element): - if hasattr(element, '__clause_element__'): + if hasattr(element, "__clause_element__"): element = element.__clause_element__() if not isinstance(element, Column): raise exc.ArgumentError("schema.Column object expected") @@ -2567,9 +2693,9 @@ def _to_schema_column(element): def _to_schema_column_or_string(element): - if hasattr(element, '__clause_element__'): + if hasattr(element, "__clause_element__"): element = element.__clause_element__() - if not isinstance(element, util.string_types + (ColumnElement, )): + if not isinstance(element, util.string_types + (ColumnElement,)): msg = "Element %r is not a string name or column element" raise exc.ArgumentError(msg % element) return element @@ -2588,11 +2714,12 @@ class ColumnCollectionMixin(object): _allow_multiple_tables = False def __init__(self, *columns, **kw): - _autoattach = kw.pop('_autoattach', True) - self._column_flag = kw.pop('_column_flag', False) + _autoattach = kw.pop("_autoattach", True) + self._column_flag = kw.pop("_column_flag", False) self.columns = ColumnCollection() - self._pending_colargs = [_to_schema_column_or_string(c) - for c in columns] + self._pending_colargs = [ + _to_schema_column_or_string(c) for c in columns + ] if _autoattach and self._pending_colargs: self._check_attach() @@ -2601,7 +2728,7 @@ class ColumnCollectionMixin(object): for expr in expressions: strname = None column = None - if hasattr(expr, '__clause_element__'): + if hasattr(expr, "__clause_element__"): expr = expr.__clause_element__() if not isinstance(expr, (ColumnElement, TextClause)): @@ -2609,21 +2736,16 @@ class ColumnCollectionMixin(object): strname = expr else: cols = [] - visitors.traverse(expr, {}, {'column': cols.append}) + visitors.traverse(expr, {}, {"column": cols.append}) if cols: column = cols[0] add_element = column if column is not None else strname yield expr, column, strname, add_element def _check_attach(self, evt=False): - col_objs = [ - c for c in self._pending_colargs - if isinstance(c, Column) - ] + col_objs = [c for c in self._pending_colargs if isinstance(c, Column)] - cols_w_table = [ - c for c in col_objs if isinstance(c.table, Table) - ] + cols_w_table = [c for c in col_objs if isinstance(c.table, Table)] cols_wo_table = set(col_objs).difference(cols_w_table) @@ -2636,6 +2758,7 @@ class ColumnCollectionMixin(object): # columns are specified as strings. has_string_cols = set(self._pending_colargs).difference(col_objs) if not has_string_cols: + def _col_attached(column, table): # this isinstance() corresponds with the # isinstance() above; only want to count Table-bound @@ -2644,6 +2767,7 @@ class ColumnCollectionMixin(object): cols_wo_table.discard(column) if not cols_wo_table: self._check_attach(evt=True) + self._cols_wo_table = cols_wo_table for col in cols_wo_table: col._on_table_attach(_col_attached) @@ -2659,9 +2783,11 @@ class ColumnCollectionMixin(object): others = [c for c in columns[1:] if c.table is not table] if others: raise exc.ArgumentError( - "Column(s) %s are not part of table '%s'." % - (", ".join("'%s'" % c for c in others), - table.description) + "Column(s) %s are not part of table '%s'." + % ( + ", ".join("'%s'" % c for c in others), + table.description, + ) ) def _set_parent(self, table): @@ -2694,11 +2820,12 @@ class ColumnCollectionConstraint(ColumnCollectionMixin, Constraint): arguments are propagated to the :class:`.Constraint` superclass. """ - _autoattach = kw.pop('_autoattach', True) - _column_flag = kw.pop('_column_flag', False) + _autoattach = kw.pop("_autoattach", True) + _column_flag = kw.pop("_column_flag", False) Constraint.__init__(self, **kw) ColumnCollectionMixin.__init__( - self, *columns, _autoattach=_autoattach, _column_flag=_column_flag) + self, *columns, _autoattach=_autoattach, _column_flag=_column_flag + ) columns = None """A :class:`.ColumnCollection` representing the set of columns @@ -2714,8 +2841,12 @@ class ColumnCollectionConstraint(ColumnCollectionMixin, Constraint): return x in self.columns def copy(self, **kw): - c = self.__class__(name=self.name, deferrable=self.deferrable, - initially=self.initially, *self.columns.keys()) + c = self.__class__( + name=self.name, + deferrable=self.deferrable, + initially=self.initially, + *self.columns.keys() + ) return self._schema_item_copy(c) def contains_column(self, col): @@ -2747,9 +2878,19 @@ class CheckConstraint(ColumnCollectionConstraint): _allow_multiple_tables = True - def __init__(self, sqltext, name=None, deferrable=None, - initially=None, table=None, info=None, _create_rule=None, - _autoattach=True, _type_bound=False, **kw): + def __init__( + self, + sqltext, + name=None, + deferrable=None, + initially=None, + table=None, + info=None, + _create_rule=None, + _autoattach=True, + _type_bound=False, + **kw + ): r"""Construct a CHECK constraint. :param sqltext: @@ -2781,14 +2922,19 @@ class CheckConstraint(ColumnCollectionConstraint): self.sqltext = _literal_as_text(sqltext, warn=False) columns = [] - visitors.traverse(self.sqltext, {}, {'column': columns.append}) - - super(CheckConstraint, self).\ - __init__( - name=name, deferrable=deferrable, - initially=initially, _create_rule=_create_rule, info=info, - _type_bound=_type_bound, _autoattach=_autoattach, - *columns, **kw) + visitors.traverse(self.sqltext, {}, {"column": columns.append}) + + super(CheckConstraint, self).__init__( + name=name, + deferrable=deferrable, + initially=initially, + _create_rule=_create_rule, + info=info, + _type_bound=_type_bound, + _autoattach=_autoattach, + *columns, + **kw + ) if table is not None: self._set_parent_with_dispatch(table) @@ -2797,22 +2943,24 @@ class CheckConstraint(ColumnCollectionConstraint): return "check_constraint" else: return "column_check_constraint" + __visit_name__ = property(__visit_name__) def copy(self, target_table=None, **kw): if target_table is not None: - sqltext = _copy_expression( - self.sqltext, self.table, target_table) + sqltext = _copy_expression(self.sqltext, self.table, target_table) else: sqltext = self.sqltext - c = CheckConstraint(sqltext, - name=self.name, - initially=self.initially, - deferrable=self.deferrable, - _create_rule=self._create_rule, - table=target_table, - _autoattach=False, - _type_bound=self._type_bound) + c = CheckConstraint( + sqltext, + name=self.name, + initially=self.initially, + deferrable=self.deferrable, + _create_rule=self._create_rule, + table=target_table, + _autoattach=False, + _type_bound=self._type_bound, + ) return self._schema_item_copy(c) @@ -2828,12 +2976,25 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): Examples of foreign key configuration are in :ref:`metadata_foreignkeys`. """ - __visit_name__ = 'foreign_key_constraint' - def __init__(self, columns, refcolumns, name=None, onupdate=None, - ondelete=None, deferrable=None, initially=None, - use_alter=False, link_to_name=False, match=None, - table=None, info=None, **dialect_kw): + __visit_name__ = "foreign_key_constraint" + + def __init__( + self, + columns, + refcolumns, + name=None, + onupdate=None, + ondelete=None, + deferrable=None, + initially=None, + use_alter=False, + link_to_name=False, + match=None, + table=None, + info=None, + **dialect_kw + ): r"""Construct a composite-capable FOREIGN KEY. :param columns: A sequence of local column names. The named columns @@ -2905,8 +3066,13 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): """ Constraint.__init__( - self, name=name, deferrable=deferrable, initially=initially, - info=info, **dialect_kw) + self, + name=name, + deferrable=deferrable, + initially=initially, + info=info, + **dialect_kw + ) self.onupdate = onupdate self.ondelete = ondelete self.link_to_name = link_to_name @@ -2927,7 +3093,8 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): raise exc.ArgumentError( "ForeignKeyConstraint number " "of constrained columns must match the number of " - "referenced columns.") + "referenced columns." + ) # standalone ForeignKeyConstraint - create # associated ForeignKey objects which will be applied to hosted @@ -2946,7 +3113,8 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): deferrable=self.deferrable, initially=self.initially, **self.dialect_kwargs - ) for refcol in refcolumns + ) + for refcol in refcolumns ] ColumnCollectionMixin.__init__(self, *columns) @@ -2978,9 +3146,7 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): @property def _elements(self): # legacy - provide a dictionary view of (column_key, fk) - return util.OrderedDict( - zip(self.column_keys, self.elements) - ) + return util.OrderedDict(zip(self.column_keys, self.elements)) @property def _referred_schema(self): @@ -3004,18 +3170,14 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): return self.elements[0].column.table def _validate_dest_table(self, table): - table_keys = set([elem._table_key() - for elem in self.elements]) + table_keys = set([elem._table_key() for elem in self.elements]) if None not in table_keys and len(table_keys) > 1: elem0, elem1 = sorted(table_keys)[0:2] raise exc.ArgumentError( - 'ForeignKeyConstraint on %s(%s) refers to ' - 'multiple remote tables: %s and %s' % ( - table.fullname, - self._col_description, - elem0, - elem1 - )) + "ForeignKeyConstraint on %s(%s) refers to " + "multiple remote tables: %s and %s" + % (table.fullname, self._col_description, elem0, elem1) + ) @property def column_keys(self): @@ -3034,8 +3196,8 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): return self.columns.keys() else: return [ - col.key if isinstance(col, ColumnElement) - else str(col) for col in self._pending_colargs + col.key if isinstance(col, ColumnElement) else str(col) + for col in self._pending_colargs ] @property @@ -3051,11 +3213,11 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): raise exc.ArgumentError( "Can't create ForeignKeyConstraint " "on table '%s': no column " - "named '%s' is present." % (table.description, ke.args[0])) + "named '%s' is present." % (table.description, ke.args[0]) + ) for col, fk in zip(self.columns, self.elements): - if not hasattr(fk, 'parent') or \ - fk.parent is not col: + if not hasattr(fk, "parent") or fk.parent is not col: fk._set_parent_with_dispatch(col) self._validate_dest_table(table) @@ -3063,13 +3225,16 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): def copy(self, schema=None, target_table=None, **kw): fkc = ForeignKeyConstraint( [x.parent.key for x in self.elements], - [x._get_colspec( - schema=schema, - table_name=target_table.name - if target_table is not None - and x._table_key() == x.parent.table.key - else None) - for x in self.elements], + [ + x._get_colspec( + schema=schema, + table_name=target_table.name + if target_table is not None + and x._table_key() == x.parent.table.key + else None, + ) + for x in self.elements + ], name=self.name, onupdate=self.onupdate, ondelete=self.ondelete, @@ -3077,11 +3242,9 @@ class ForeignKeyConstraint(ColumnCollectionConstraint): deferrable=self.deferrable, initially=self.initially, link_to_name=self.link_to_name, - match=self.match + match=self.match, ) - for self_fk, other_fk in zip( - self.elements, - fkc.elements): + for self_fk, other_fk in zip(self.elements, fkc.elements): self_fk._schema_item_copy(other_fk) return self._schema_item_copy(fkc) @@ -3160,10 +3323,10 @@ class PrimaryKeyConstraint(ColumnCollectionConstraint): """ - __visit_name__ = 'primary_key_constraint' + __visit_name__ = "primary_key_constraint" def __init__(self, *columns, **kw): - self._implicit_generated = kw.pop('_implicit_generated', False) + self._implicit_generated = kw.pop("_implicit_generated", False) super(PrimaryKeyConstraint, self).__init__(*columns, **kw) def _set_parent(self, table): @@ -3175,18 +3338,21 @@ class PrimaryKeyConstraint(ColumnCollectionConstraint): table.constraints.add(self) table_pks = [c for c in table.c if c.primary_key] - if self.columns and table_pks and \ - set(table_pks) != set(self.columns.values()): + if ( + self.columns + and table_pks + and set(table_pks) != set(self.columns.values()) + ): util.warn( "Table '%s' specifies columns %s as primary_key=True, " "not matching locally specified columns %s; setting the " "current primary key columns to %s. This warning " - "may become an exception in a future release" % - ( + "may become an exception in a future release" + % ( table.name, ", ".join("'%s'" % c.name for c in table_pks), ", ".join("'%s'" % c.name for c in self.columns), - ", ".join("'%s'" % c.name for c in self.columns) + ", ".join("'%s'" % c.name for c in self.columns), ) ) table_pks[:] = [] @@ -3241,28 +3407,28 @@ class PrimaryKeyConstraint(ColumnCollectionConstraint): @util.memoized_property def _autoincrement_column(self): - def _validate_autoinc(col, autoinc_true): if col.type._type_affinity is None or not issubclass( - col.type._type_affinity, - type_api.INTEGERTYPE._type_affinity): + col.type._type_affinity, type_api.INTEGERTYPE._type_affinity + ): if autoinc_true: raise exc.ArgumentError( "Column type %s on column '%s' is not " - "compatible with autoincrement=True" % ( - col.type, - col - )) + "compatible with autoincrement=True" % (col.type, col) + ) else: return False - elif not isinstance(col.default, (type(None), Sequence)) and \ - not autoinc_true: - return False + elif ( + not isinstance(col.default, (type(None), Sequence)) + and not autoinc_true + ): + return False elif col.server_default is not None and not autoinc_true: return False - elif ( - col.foreign_keys and col.autoincrement - not in (True, 'ignore_fk')): + elif col.foreign_keys and col.autoincrement not in ( + True, + "ignore_fk", + ): return False return True @@ -3272,10 +3438,10 @@ class PrimaryKeyConstraint(ColumnCollectionConstraint): if col.autoincrement is True: _validate_autoinc(col, True) return col - elif ( - col.autoincrement in ('auto', 'ignore_fk') and - _validate_autoinc(col, False) - ): + elif col.autoincrement in ( + "auto", + "ignore_fk", + ) and _validate_autoinc(col, False): return col else: @@ -3286,8 +3452,8 @@ class PrimaryKeyConstraint(ColumnCollectionConstraint): if autoinc is not None: raise exc.ArgumentError( "Only one Column may be marked " - "autoincrement=True, found both %s and %s." % - (col.name, autoinc.name) + "autoincrement=True, found both %s and %s." + % (col.name, autoinc.name) ) else: autoinc = col @@ -3304,7 +3470,7 @@ class UniqueConstraint(ColumnCollectionConstraint): UniqueConstraint. """ - __visit_name__ = 'unique_constraint' + __visit_name__ = "unique_constraint" class Index(DialectKWArgs, ColumnCollectionMixin, SchemaItem): @@ -3382,7 +3548,7 @@ class Index(DialectKWArgs, ColumnCollectionMixin, SchemaItem): """ - __visit_name__ = 'index' + __visit_name__ = "index" def __init__(self, name, *expressions, **kw): r"""Construct an index object. @@ -3420,30 +3586,35 @@ class Index(DialectKWArgs, ColumnCollectionMixin, SchemaItem): columns = [] processed_expressions = [] - for expr, column, strname, add_element in self.\ - _extract_col_expression_collection(expressions): + for ( + expr, + column, + strname, + add_element, + ) in self._extract_col_expression_collection(expressions): if add_element is not None: columns.append(add_element) processed_expressions.append(expr) self.expressions = processed_expressions self.name = quoted_name(name, kw.pop("quote", None)) - self.unique = kw.pop('unique', False) - _column_flag = kw.pop('_column_flag', False) - if 'info' in kw: - self.info = kw.pop('info') + self.unique = kw.pop("unique", False) + _column_flag = kw.pop("_column_flag", False) + if "info" in kw: + self.info = kw.pop("info") # TODO: consider "table" argument being public, but for # the purpose of the fix here, it starts as private. - if '_table' in kw: - table = kw.pop('_table') + if "_table" in kw: + table = kw.pop("_table") self._validate_dialect_kwargs(kw) # will call _set_parent() if table-bound column # objects are present ColumnCollectionMixin.__init__( - self, *columns, _column_flag=_column_flag) + self, *columns, _column_flag=_column_flag + ) if table is not None: self._set_parent(table) @@ -3454,20 +3625,17 @@ class Index(DialectKWArgs, ColumnCollectionMixin, SchemaItem): if self.table is not None and table is not self.table: raise exc.ArgumentError( "Index '%s' is against table '%s', and " - "cannot be associated with table '%s'." % ( - self.name, - self.table.description, - table.description - ) + "cannot be associated with table '%s'." + % (self.name, self.table.description, table.description) ) self.table = table table.indexes.add(self) self.expressions = [ - expr if isinstance(expr, ClauseElement) - else colexpr - for expr, colexpr in util.zip_longest(self.expressions, - self.columns) + expr if isinstance(expr, ClauseElement) else colexpr + for expr, colexpr in util.zip_longest( + self.expressions, self.columns + ) ] @property @@ -3506,17 +3674,16 @@ class Index(DialectKWArgs, ColumnCollectionMixin, SchemaItem): bind._run_visitor(ddl.SchemaDropper, self) def __repr__(self): - return 'Index(%s)' % ( + return "Index(%s)" % ( ", ".join( - [repr(self.name)] + - [repr(e) for e in self.expressions] + - (self.unique and ["unique=True"] or []) - )) + [repr(self.name)] + + [repr(e) for e in self.expressions] + + (self.unique and ["unique=True"] or []) + ) + ) -DEFAULT_NAMING_CONVENTION = util.immutabledict({ - "ix": 'ix_%(column_0_label)s' -}) +DEFAULT_NAMING_CONVENTION = util.immutabledict({"ix": "ix_%(column_0_label)s"}) class MetaData(SchemaItem): @@ -3542,13 +3709,17 @@ class MetaData(SchemaItem): """ - __visit_name__ = 'metadata' - - def __init__(self, bind=None, reflect=False, schema=None, - quote_schema=None, - naming_convention=DEFAULT_NAMING_CONVENTION, - info=None - ): + __visit_name__ = "metadata" + + def __init__( + self, + bind=None, + reflect=False, + schema=None, + quote_schema=None, + naming_convention=DEFAULT_NAMING_CONVENTION, + info=None, + ): """Create a new MetaData object. :param bind: @@ -3712,12 +3883,15 @@ class MetaData(SchemaItem): self.bind = bind if reflect: - util.warn_deprecated("reflect=True is deprecate; please " - "use the reflect() method.") + util.warn_deprecated( + "reflect=True is deprecate; please " + "use the reflect() method." + ) if not bind: raise exc.ArgumentError( "A bind must be supplied in conjunction " - "with reflect=True") + "with reflect=True" + ) self.reflect() tables = None @@ -3735,7 +3909,7 @@ class MetaData(SchemaItem): """ def __repr__(self): - return 'MetaData(bind=%r)' % self.bind + return "MetaData(bind=%r)" % self.bind def __contains__(self, table_or_key): if not isinstance(table_or_key, util.string_types): @@ -3755,27 +3929,32 @@ class MetaData(SchemaItem): for fk in removed.foreign_keys: fk._remove_from_metadata(self) if self._schemas: - self._schemas = set([t.schema - for t in self.tables.values() - if t.schema is not None]) + self._schemas = set( + [ + t.schema + for t in self.tables.values() + if t.schema is not None + ] + ) def __getstate__(self): - return {'tables': self.tables, - 'schema': self.schema, - 'schemas': self._schemas, - 'sequences': self._sequences, - 'fk_memos': self._fk_memos, - 'naming_convention': self.naming_convention - } + return { + "tables": self.tables, + "schema": self.schema, + "schemas": self._schemas, + "sequences": self._sequences, + "fk_memos": self._fk_memos, + "naming_convention": self.naming_convention, + } def __setstate__(self, state): - self.tables = state['tables'] - self.schema = state['schema'] - self.naming_convention = state['naming_convention'] + self.tables = state["tables"] + self.schema = state["schema"] + self.naming_convention = state["naming_convention"] self._bind = None - self._sequences = state['sequences'] - self._schemas = state['schemas'] - self._fk_memos = state['fk_memos'] + self._sequences = state["sequences"] + self._schemas = state["schemas"] + self._fk_memos = state["fk_memos"] def is_bound(self): """True if this MetaData is bound to an Engine or Connection.""" @@ -3805,10 +3984,11 @@ class MetaData(SchemaItem): def _bind_to(self, url, bind): """Bind this MetaData to an Engine, Connection, string or URL.""" - if isinstance(bind, util.string_types + (url.URL, )): + if isinstance(bind, util.string_types + (url.URL,)): self._bind = sqlalchemy.create_engine(bind) else: self._bind = bind + bind = property(bind, _bind_to) def clear(self): @@ -3858,12 +4038,20 @@ class MetaData(SchemaItem): """ - return ddl.sort_tables(sorted(self.tables.values(), key=lambda t: t.key)) + return ddl.sort_tables( + sorted(self.tables.values(), key=lambda t: t.key) + ) - def reflect(self, bind=None, schema=None, views=False, only=None, - extend_existing=False, - autoload_replace=True, - **dialect_kwargs): + def reflect( + self, + bind=None, + schema=None, + views=False, + only=None, + extend_existing=False, + autoload_replace=True, + **dialect_kwargs + ): r"""Load all available table definitions from the database. Automatically creates ``Table`` entries in this ``MetaData`` for any @@ -3926,11 +4114,11 @@ class MetaData(SchemaItem): with bind.connect() as conn: reflect_opts = { - 'autoload': True, - 'autoload_with': conn, - 'extend_existing': extend_existing, - 'autoload_replace': autoload_replace, - '_extend_on': set() + "autoload": True, + "autoload_with": conn, + "extend_existing": extend_existing, + "autoload_replace": autoload_replace, + "_extend_on": set(), } reflect_opts.update(dialect_kwargs) @@ -3939,42 +4127,49 @@ class MetaData(SchemaItem): schema = self.schema if schema is not None: - reflect_opts['schema'] = schema + reflect_opts["schema"] = schema available = util.OrderedSet( - bind.engine.table_names(schema, connection=conn)) + bind.engine.table_names(schema, connection=conn) + ) if views: - available.update( - bind.dialect.get_view_names(conn, schema) - ) + available.update(bind.dialect.get_view_names(conn, schema)) if schema is not None: - available_w_schema = util.OrderedSet(["%s.%s" % (schema, name) - for name in available]) + available_w_schema = util.OrderedSet( + ["%s.%s" % (schema, name) for name in available] + ) else: available_w_schema = available current = set(self.tables) if only is None: - load = [name for name, schname in - zip(available, available_w_schema) - if extend_existing or schname not in current] + load = [ + name + for name, schname in zip(available, available_w_schema) + if extend_existing or schname not in current + ] elif util.callable(only): - load = [name for name, schname in - zip(available, available_w_schema) - if (extend_existing or schname not in current) - and only(name, self)] + load = [ + name + for name, schname in zip(available, available_w_schema) + if (extend_existing or schname not in current) + and only(name, self) + ] else: missing = [name for name in only if name not in available] if missing: - s = schema and (" schema '%s'" % schema) or '' + s = schema and (" schema '%s'" % schema) or "" raise exc.InvalidRequestError( - 'Could not reflect: requested table(s) not available ' - 'in %r%s: (%s)' % - (bind.engine, s, ', '.join(missing))) - load = [name for name in only if extend_existing or - name not in current] + "Could not reflect: requested table(s) not available " + "in %r%s: (%s)" % (bind.engine, s, ", ".join(missing)) + ) + load = [ + name + for name in only + if extend_existing or name not in current + ] for name in load: try: @@ -3989,11 +4184,12 @@ class MetaData(SchemaItem): See :class:`.DDLEvents`. """ + def adapt_listener(target, connection, **kw): - tables = kw['tables'] + tables = kw["tables"] listener(event, target, connection, tables=tables) - event.listen(self, "" + event_name.replace('-', '_'), adapt_listener) + event.listen(self, "" + event_name.replace("-", "_"), adapt_listener) def create_all(self, bind=None, tables=None, checkfirst=True): """Create all tables stored in this metadata. @@ -4017,10 +4213,9 @@ class MetaData(SchemaItem): """ if bind is None: bind = _bind_or_error(self) - bind._run_visitor(ddl.SchemaGenerator, - self, - checkfirst=checkfirst, - tables=tables) + bind._run_visitor( + ddl.SchemaGenerator, self, checkfirst=checkfirst, tables=tables + ) def drop_all(self, bind=None, tables=None, checkfirst=True): """Drop all tables stored in this metadata. @@ -4044,10 +4239,9 @@ class MetaData(SchemaItem): """ if bind is None: bind = _bind_or_error(self) - bind._run_visitor(ddl.SchemaDropper, - self, - checkfirst=checkfirst, - tables=tables) + bind._run_visitor( + ddl.SchemaDropper, self, checkfirst=checkfirst, tables=tables + ) class ThreadLocalMetaData(MetaData): @@ -4064,7 +4258,7 @@ class ThreadLocalMetaData(MetaData): """ - __visit_name__ = 'metadata' + __visit_name__ = "metadata" def __init__(self): """Construct a ThreadLocalMetaData.""" @@ -4080,13 +4274,13 @@ class ThreadLocalMetaData(MetaData): string or URL to automatically create a basic Engine for this bind with ``create_engine()``.""" - return getattr(self.context, '_engine', None) + return getattr(self.context, "_engine", None) @util.dependencies("sqlalchemy.engine.url") def _bind_to(self, url, bind): """Bind to a Connectable in the caller's thread.""" - if isinstance(bind, util.string_types + (url.URL, )): + if isinstance(bind, util.string_types + (url.URL,)): try: self.context._engine = self.__engines[bind] except KeyError: @@ -4104,14 +4298,16 @@ class ThreadLocalMetaData(MetaData): def is_bound(self): """True if there is a bind for this thread.""" - return (hasattr(self.context, '_engine') and - self.context._engine is not None) + return ( + hasattr(self.context, "_engine") + and self.context._engine is not None + ) def dispose(self): """Dispose all bound engines, in all thread contexts.""" for e in self.__engines.values(): - if hasattr(e, 'dispose'): + if hasattr(e, "dispose"): e.dispose() @@ -4128,22 +4324,25 @@ class _SchemaTranslateMap(object): """ - __slots__ = 'map_', '__call__', 'hash_key', 'is_default' + + __slots__ = "map_", "__call__", "hash_key", "is_default" _default_schema_getter = operator.attrgetter("schema") def __init__(self, map_): self.map_ = map_ if map_ is not None: + def schema_for_object(obj): effective_schema = self._default_schema_getter(obj) effective_schema = obj._translate_schema( - effective_schema, map_) + effective_schema, map_ + ) return effective_schema + self.__call__ = schema_for_object self.hash_key = ";".join( - "%s=%s" % (k, map_[k]) - for k in sorted(map_, key=str) + "%s=%s" % (k, map_[k]) for k in sorted(map_, key=str) ) self.is_default = False else: @@ -4160,6 +4359,6 @@ class _SchemaTranslateMap(object): else: return _SchemaTranslateMap(map_) + _default_schema_map = _SchemaTranslateMap(None) _schema_getter = _SchemaTranslateMap._schema_getter - |