diff options
Diffstat (limited to 'lib/sqlalchemy')
41 files changed, 76 insertions, 76 deletions
diff --git a/lib/sqlalchemy/dialects/mssql/base.py b/lib/sqlalchemy/dialects/mssql/base.py index 4a83c0854..93dc9d88a 100644 --- a/lib/sqlalchemy/dialects/mssql/base.py +++ b/lib/sqlalchemy/dialects/mssql/base.py @@ -561,7 +561,7 @@ is compatible with SQL2000 while running on a SQL2005 database server. ``server_version_info`` will always return the database server version information (in this case SQL2005) and not the compatibility level information. Because of this, if running under -a backwards compatibility mode SQAlchemy may attempt to use T-SQL +a backwards compatibility mode SQLAlchemy may attempt to use T-SQL statements that are unable to be parsed by the database server. Triggers diff --git a/lib/sqlalchemy/dialects/mysql/base.py b/lib/sqlalchemy/dialects/mysql/base.py index f5305d7b1..76b52e0d7 100644 --- a/lib/sqlalchemy/dialects/mysql/base.py +++ b/lib/sqlalchemy/dialects/mysql/base.py @@ -294,7 +294,7 @@ most efficient place for this additional keyword to be passed. `Character set introducers <https://dev.mysql.com/doc/refman/5.7/en/charset-introducer.html>`_ - on the MySQL website -Ansi Quoting Style +ANSI Quoting Style ------------------ MySQL features two varieties of identifier "quoting style", one using diff --git a/lib/sqlalchemy/dialects/mysql/dml.py b/lib/sqlalchemy/dialects/mysql/dml.py index 59cd22d36..68d46588e 100644 --- a/lib/sqlalchemy/dialects/mysql/dml.py +++ b/lib/sqlalchemy/dialects/mysql/dml.py @@ -25,7 +25,7 @@ class Insert(StandardInsert): MySQL's ON DUPLICATE KEY UPDATE clause allows reference to the row that would be inserted, via a special function called ``VALUES()``. - This attribute provides all columns in this row to be referenaceable + This attribute provides all columns in this row to be referenceable such that they will render within a ``VALUES()`` function inside the ON DUPLICATE KEY UPDATE clause. The attribute is named ``.inserted`` so as not to conflict with the existing :meth:`.Insert.values` method. @@ -68,7 +68,7 @@ class Insert(StandardInsert): Passing a list of 2-tuples indicates that the parameter assignments in the UPDATE clause should be ordered as sent, in a manner similar - to that described for the :class:`.Update` contruct overall + to that described for the :class:`.Update` construct overall in :ref:`updates_order_parameters`:: insert().on_duplicate_key_update( diff --git a/lib/sqlalchemy/dialects/oracle/base.py b/lib/sqlalchemy/dialects/oracle/base.py index f8ce48ece..95a6c1d21 100644 --- a/lib/sqlalchemy/dialects/oracle/base.py +++ b/lib/sqlalchemy/dialects/oracle/base.py @@ -329,8 +329,8 @@ Index compression ~~~~~~~~~~~~~~~~~ Oracle has a more efficient storage mode for indexes containing lots of -repeated values. Use the ``oracle_compress`` parameter to turn on key c -ompression:: +repeated values. Use the ``oracle_compress`` parameter to turn on key +compression:: Index('my_index', my_table.c.data, oracle_compress=True) diff --git a/lib/sqlalchemy/dialects/oracle/cx_oracle.py b/lib/sqlalchemy/dialects/oracle/cx_oracle.py index abeef39d2..3bb3af3f7 100644 --- a/lib/sqlalchemy/dialects/oracle/cx_oracle.py +++ b/lib/sqlalchemy/dialects/oracle/cx_oracle.py @@ -120,7 +120,7 @@ VARCHAR2, CHAR, and CLOB, the flag ``coerce_to_unicode=False`` can be passed to .. versionchanged:: 1.3 Unicode conversion is applied to all string values by default under python 2. The ``coerce_to_unicode`` now defaults to True - and can be set to False to disable the Unicode coersion of strings that are + and can be set to False to disable the Unicode coercion of strings that are delivered as VARCHAR2/CHAR/CLOB data. @@ -142,11 +142,11 @@ altering the type coercion behavior at the same time. Users of the cx_Oracle dialect are **strongly encouraged** to read through cx_Oracle's list of built-in datatype symbols at http://cx-oracle.readthedocs.io/en/latest/module.html#types. -Note that in some cases, signficant performance degradation can occur when +Note that in some cases, significant performance degradation can occur when using these types vs. not, in particular when specifying ``cx_Oracle.CLOB``. On the SQLAlchemy side, the :meth:`.DialectEvents.do_setinputsizes` event can -be used both for runtime visibliity (e.g. logging) of the setinputsizes step as +be used both for runtime visibility (e.g. logging) of the setinputsizes step as well as to fully control how ``setinputsizes()`` is used on a per-statement basis. diff --git a/lib/sqlalchemy/dialects/postgresql/base.py b/lib/sqlalchemy/dialects/postgresql/base.py index e9040fb43..4004a2b9a 100644 --- a/lib/sqlalchemy/dialects/postgresql/base.py +++ b/lib/sqlalchemy/dialects/postgresql/base.py @@ -2224,7 +2224,7 @@ class PGInspector(reflection.Inspector): """Return a list of FOREIGN TABLE names. Behavior is similar to that of :meth:`.Inspector.get_table_names`, - except that the list is limited to those tables tha report a + except that the list is limited to those tables that report a ``relkind`` value of ``f``. .. versionadded:: 1.0.0 diff --git a/lib/sqlalchemy/dialects/sqlite/base.py b/lib/sqlalchemy/dialects/sqlite/base.py index 15e18f3fd..bc7f7fce4 100644 --- a/lib/sqlalchemy/dialects/sqlite/base.py +++ b/lib/sqlalchemy/dialects/sqlite/base.py @@ -18,7 +18,7 @@ SQLite does not have built-in DATE, TIME, or DATETIME types, and pysqlite does not provide out of the box functionality for translating values between Python `datetime` objects and a SQLite-supported format. SQLAlchemy's own :class:`~sqlalchemy.types.DateTime` and related types provide date formatting -and parsing functionality when SQlite is used. The implementation classes are +and parsing functionality when SQLite is used. The implementation classes are :class:`~.sqlite.DATETIME`, :class:`~.sqlite.DATE` and :class:`~.sqlite.TIME`. These types represent dates and times as ISO formatted strings, which also nicely support ordering. There's no reliance on typical "libc" internals for @@ -139,7 +139,7 @@ only ``connection.commit()`` and ``connection.rollback()``, upon which a new transaction is to be begun immediately. This may seem to imply that the SQLite driver would in theory allow only a single filehandle on a particular database file at any time; however, there are several -factors both within SQlite itself as well as within the pysqlite driver +factors both within SQLite itself as well as within the pysqlite driver which loosen this restriction significantly. However, no matter what locking modes are used, SQLite will still always @@ -223,7 +223,7 @@ Transactional DDL The SQLite database supports transactional :term:`DDL` as well. In this case, the pysqlite driver is not only failing to start transactions, -it also is ending any existing transction when DDL is detected, so again, +it also is ending any existing transaction when DDL is detected, so again, workarounds are required. .. warning:: diff --git a/lib/sqlalchemy/engine/default.py b/lib/sqlalchemy/engine/default.py index e54e99b75..58c09a3ac 100644 --- a/lib/sqlalchemy/engine/default.py +++ b/lib/sqlalchemy/engine/default.py @@ -1339,7 +1339,7 @@ class DefaultExecutionContext(interfaces.ExecutionContext): with the name. :param isolate_multiinsert_groups=True: indicates that multi-valued - INSERT contructs created using :meth:`.Insert.values` should be + INSERT constructs created using :meth:`.Insert.values` should be handled by returning only the subset of parameters that are local to the current column default invocation. When ``False``, the raw parameters of the statement are returned including the diff --git a/lib/sqlalchemy/engine/interfaces.py b/lib/sqlalchemy/engine/interfaces.py index d579e6fdb..3142c0c6b 100644 --- a/lib/sqlalchemy/engine/interfaces.py +++ b/lib/sqlalchemy/engine/interfaces.py @@ -901,7 +901,7 @@ class CreateEnginePlugin(object): """ def __init__(self, url, kwargs): - """Contruct a new :class:`.CreateEnginePlugin`. + """Construct a new :class:`.CreateEnginePlugin`. The plugin object is instantiated individually for each call to :func:`.create_engine`. A single :class:`.Engine` will be diff --git a/lib/sqlalchemy/engine/result.py b/lib/sqlalchemy/engine/result.py index 9255343e1..fcb1d4155 100644 --- a/lib/sqlalchemy/engine/result.py +++ b/lib/sqlalchemy/engine/result.py @@ -363,7 +363,7 @@ class ResultMetaData(object): The remaining fairly common case is that of the textual SQL that includes at least partial column information; this is when - we use a :class:`.TextAsFrom` construct. This contruct may have + we use a :class:`.TextAsFrom` construct. This construct may have unordered or ordered column information. In the ordered case, we merge the cursor.description and the compiled construct's information positionally, and warn if there are additional description names @@ -901,7 +901,7 @@ class ResultProxy(object): def close(self): """Close this ResultProxy. - This closes out the underlying DBAPI cursor corresonding + This closes out the underlying DBAPI cursor corresponding to the statement execution, if one is still present. Note that the DBAPI cursor is automatically released when the :class:`.ResultProxy` exhausts all available rows. :meth:`.ResultProxy.close` is generally diff --git a/lib/sqlalchemy/exc.py b/lib/sqlalchemy/exc.py index 1cfb3470b..b9e2f9339 100644 --- a/lib/sqlalchemy/exc.py +++ b/lib/sqlalchemy/exc.py @@ -266,7 +266,7 @@ class NoSuchTableError(InvalidRequestError): class UnreflectableTableError(InvalidRequestError): - """Table exists but can't be reflectted for some reason. + """Table exists but can't be reflected for some reason. .. versionadded:: 1.2 diff --git a/lib/sqlalchemy/ext/associationproxy.py b/lib/sqlalchemy/ext/associationproxy.py index 5b05d2b3d..12e6c1f52 100644 --- a/lib/sqlalchemy/ext/associationproxy.py +++ b/lib/sqlalchemy/ext/associationproxy.py @@ -85,7 +85,7 @@ ASSOCIATION_PROXY = util.symbol("ASSOCIATION_PROXY") of type :class:`.AssociationProxy`. Is assigned to the :attr:`.InspectionAttr.extension_type` - attibute. + attribute. """ diff --git a/lib/sqlalchemy/ext/automap.py b/lib/sqlalchemy/ext/automap.py index 47a713845..55ab325a3 100644 --- a/lib/sqlalchemy/ext/automap.py +++ b/lib/sqlalchemy/ext/automap.py @@ -349,7 +349,7 @@ is as follows: 5. The override logic for many-to-many works the same as that of one-to-many/ many-to-one; the :func:`.generate_relationship` function is called upon - to generate the strucures and existing attributes will be maintained. + to generate the structures and existing attributes will be maintained. Relationships with Inheritance ------------------------------ @@ -673,7 +673,7 @@ class AutomapBase(object): function. In practice, the :class:`.AutomapBase` class is always used as a mixin along with an actual declarative base. - A new subclassable :class:`.AutomapBase` is typically instantated + A new subclassable :class:`.AutomapBase` is typically instantiated using the :func:`.automap_base` function. .. seealso:: diff --git a/lib/sqlalchemy/ext/declarative/api.py b/lib/sqlalchemy/ext/declarative/api.py index 6e64e37c5..139481ba5 100644 --- a/lib/sqlalchemy/ext/declarative/api.py +++ b/lib/sqlalchemy/ext/declarative/api.py @@ -528,7 +528,7 @@ class AbstractConcreteBase(ConcreteBase): at class configuration time, it behaves like a declarative mixin or an ``__abstract__`` base class. Once classes are configured and mappings are produced, it then gets mapped itself, but - after all of its decscendants. This is a very unique system of mapping + after all of its descendants. This is a very unique system of mapping not found in any other SQLAlchemy system. Using this approach, we can specify columns and properties diff --git a/lib/sqlalchemy/ext/hybrid.py b/lib/sqlalchemy/ext/hybrid.py index 1718efc25..556514bab 100644 --- a/lib/sqlalchemy/ext/hybrid.py +++ b/lib/sqlalchemy/ext/hybrid.py @@ -779,7 +779,7 @@ HYBRID_METHOD = util.symbol("HYBRID_METHOD") of type :class:`.hybrid_method`. Is assigned to the :attr:`.InspectionAttr.extension_type` - attibute. + attribute. .. seealso:: @@ -792,7 +792,7 @@ HYBRID_PROPERTY = util.symbol("HYBRID_PROPERTY") of type :class:`.hybrid_method`. Is assigned to the :attr:`.InspectionAttr.extension_type` - attibute. + attribute. .. seealso:: diff --git a/lib/sqlalchemy/ext/indexable.py b/lib/sqlalchemy/ext/indexable.py index 5f51c7978..2bb8459c4 100644 --- a/lib/sqlalchemy/ext/indexable.py +++ b/lib/sqlalchemy/ext/indexable.py @@ -210,7 +210,7 @@ version of :class:`.postgresql.JSON`:: The ``age`` attribute at the instance level works as before; however when rendering SQL, PostgreSQL's ``->>`` operator will be used -for indexed access, instead of the usual index opearator of ``->``:: +for indexed access, instead of the usual index operator of ``->``:: >>> query = session.query(Person).filter(Person.age < 20) diff --git a/lib/sqlalchemy/ext/mutable.py b/lib/sqlalchemy/ext/mutable.py index 51d09618e..eb813a9e8 100644 --- a/lib/sqlalchemy/ext/mutable.py +++ b/lib/sqlalchemy/ext/mutable.py @@ -685,7 +685,7 @@ class MutableDict(Mutable, dict): solution for the use case of tracking deep changes to a *recursive* dictionary structure, such as a JSON structure. To support this use case, build a subclass of :class:`.MutableDict` that provides appropriate - coersion to the values placed in the dictionary so that they too are + coercion to the values placed in the dictionary so that they too are "mutable", and emit events up to their parent structure. .. seealso:: @@ -758,7 +758,7 @@ class MutableList(Mutable, list): solution for the use case of tracking deep changes to a *recursive* mutable structure, such as a JSON structure. To support this use case, build a subclass of :class:`.MutableList` that provides appropriate - coersion to the values placed in the dictionary so that they too are + coercion to the values placed in the dictionary so that they too are "mutable", and emit events up to their parent structure. .. versionadded:: 1.1 @@ -857,7 +857,7 @@ class MutableSet(Mutable, set): solution for the use case of tracking deep changes to a *recursive* mutable structure. To support this use case, build a subclass of :class:`.MutableSet` that provides appropriate - coersion to the values placed in the dictionary so that they too are + coercion to the values placed in the dictionary so that they too are "mutable", and emit events up to their parent structure. .. versionadded:: 1.1 diff --git a/lib/sqlalchemy/ext/orderinglist.py b/lib/sqlalchemy/ext/orderinglist.py index b97933dc4..16e0f1f2a 100644 --- a/lib/sqlalchemy/ext/orderinglist.py +++ b/lib/sqlalchemy/ext/orderinglist.py @@ -107,7 +107,7 @@ ordering is correct when first loaded. to lessen the impact of this limitation, however this does not take place for a UNIQUE column. A future feature will allow the "DELETE before INSERT" behavior to be - possible, allevating this limitation, though this feature will require + possible, alleviating this limitation, though this feature will require explicit configuration at the mapper level for sets of columns that are to be handled in this way. diff --git a/lib/sqlalchemy/orm/attributes.py b/lib/sqlalchemy/orm/attributes.py index cd81d759d..879b88a92 100644 --- a/lib/sqlalchemy/orm/attributes.py +++ b/lib/sqlalchemy/orm/attributes.py @@ -1643,7 +1643,7 @@ class History(History): # key situations if id(original) in _NO_STATE_SYMBOLS: deleted = () - # indicate a "del" operation occured when we don't have + # indicate a "del" operation occurred when we don't have # the previous value as: ([None], (), ()) if id(current) in _NO_STATE_SYMBOLS: current = None @@ -1673,7 +1673,7 @@ class History(History): # ignore the None in any case. if id(original) in _NO_STATE_SYMBOLS or original is None: deleted = () - # indicate a "del" operation occured when we don't have + # indicate a "del" operation occurred when we don't have # the previous value as: ([None], (), ()) if id(current) in _NO_STATE_SYMBOLS: current = None diff --git a/lib/sqlalchemy/orm/base.py b/lib/sqlalchemy/orm/base.py index 2ae817655..b64b35e72 100644 --- a/lib/sqlalchemy/orm/base.py +++ b/lib/sqlalchemy/orm/base.py @@ -195,7 +195,7 @@ NOT_EXTENSION = util.symbol( not part of sqlalchemy.ext. Is assigned to the :attr:`.InspectionAttr.extension_type` - attibute. + attribute. """, ) diff --git a/lib/sqlalchemy/orm/events.py b/lib/sqlalchemy/orm/events.py index 3ee0cd1f8..b9bad10b6 100644 --- a/lib/sqlalchemy/orm/events.py +++ b/lib/sqlalchemy/orm/events.py @@ -2134,7 +2134,7 @@ class AttributeEvents(event.Events): a changing value such as a timestamp, the :meth:`.AttributeEvents.init_scalar` event handler can also be used to **set** the newly returned value, so - that a Core-level default generation function effecively fires off + that a Core-level default generation function effectively fires off only once, but at the moment the attribute is accessed on the non-persisted object. Normally, no change to the object's state is made when an uninitialized attribute is accessed (much older @@ -2252,7 +2252,7 @@ class AttributeEvents(event.Events): from what was specified as :paramref:`.relationship.collection_class`, and will always be empty. - :param collection_adpater: the :class:`.CollectionAdapter` that will + :param collection_adapter: the :class:`.CollectionAdapter` that will mediate internal access to the collection. .. versionadded:: 1.0.0 the :meth:`.AttributeEvents.init_collection` @@ -2261,7 +2261,7 @@ class AttributeEvents(event.Events): """ - def dispose_collection(self, target, collection, collection_adpater): + def dispose_collection(self, target, collection, collection_adapter): """Receive a 'collection dispose' event. This event is triggered for a collection-based attribute when diff --git a/lib/sqlalchemy/orm/mapper.py b/lib/sqlalchemy/orm/mapper.py index ff5148ed1..12b8b4268 100644 --- a/lib/sqlalchemy/orm/mapper.py +++ b/lib/sqlalchemy/orm/mapper.py @@ -889,7 +889,7 @@ class Mapper(InspectionAttr): non_primary = None """Represent ``True`` if this :class:`.Mapper` is a "non-primary" - mapper, e.g. a mapper that is used only to selet rows but not for + mapper, e.g. a mapper that is used only to select rows but not for persistence management. This is a *read only* attribute determined during mapper construction. @@ -991,7 +991,7 @@ class Mapper(InspectionAttr): return PathRegistry.per_mapper(self) def _configure_inheritance(self): - """Configure settings related to inherting and/or inherited mappers + """Configure settings related to inheriting and/or inherited mappers being present.""" # a set of all mappers which inherit from this one. @@ -2339,7 +2339,7 @@ class Mapper(InspectionAttr): :class:`.Mapper` has several pre-filtered views of this attribute which limit the types of properties - returned, inclding :attr:`.synonyms`, :attr:`.column_attrs`, + returned, including :attr:`.synonyms`, :attr:`.column_attrs`, :attr:`.relationships`, and :attr:`.composites`. .. warning:: @@ -3166,7 +3166,7 @@ def configure_mappers(): additional options, properties, or related mappings before the operation proceeds. - * :meth:`.MapperEvents.mapper_configured` - called as each indivudal + * :meth:`.MapperEvents.mapper_configured` - called as each individual :class:`.Mapper` is configured within the process; will include all mapper state except for backrefs set up by other mappers that are still to be configured. diff --git a/lib/sqlalchemy/orm/persistence.py b/lib/sqlalchemy/orm/persistence.py index 1e3a8a44e..c90c8d91e 100644 --- a/lib/sqlalchemy/orm/persistence.py +++ b/lib/sqlalchemy/orm/persistence.py @@ -596,7 +596,7 @@ def _collect_update_commands( propkey_to_col = mapper._propkey_to_col[table] if bulk: - # keys here are mapped attrbute keys, so + # keys here are mapped attribute keys, so # look at mapper attribute keys for pk params = dict( (propkey_to_col[propkey].key, state_dict[propkey]) @@ -679,7 +679,7 @@ def _collect_update_commands( has_all_pks = True if bulk: - # keys here are mapped attrbute keys, so + # keys here are mapped attribute keys, so # look at mapper attribute keys for pk pk_params = dict( (propkey_to_col[propkey]._label, state_dict.get(propkey)) diff --git a/lib/sqlalchemy/orm/properties.py b/lib/sqlalchemy/orm/properties.py index 530eadb6b..2b323429f 100644 --- a/lib/sqlalchemy/orm/properties.py +++ b/lib/sqlalchemy/orm/properties.py @@ -7,7 +7,7 @@ """MapperProperty implementations. -This is a private module which defines the behavior of invidual ORM- +This is a private module which defines the behavior of individual ORM- mapped attributes. """ diff --git a/lib/sqlalchemy/orm/query.py b/lib/sqlalchemy/orm/query.py index 0db8b6dd0..80d596b4c 100644 --- a/lib/sqlalchemy/orm/query.py +++ b/lib/sqlalchemy/orm/query.py @@ -819,7 +819,7 @@ class Query(object): The :meth:`.Query.yield_per` method **is not compatible subqueryload eager loading or joinedload eager loading when using collections**. It is potentially compatible with "select in" - eager loading, **provided the databse driver supports multiple, + eager loading, **provided the database driver supports multiple, independent cursors** (pysqlite and psycopg2 are known to work, MySQL and SQL Server ODBC drivers do not). @@ -959,7 +959,7 @@ class Query(object): :param identity_token: identity token that should be used to create the identity key. Used as is, however overriding subclasses can repurpose this in order to interpret the value in a special way, - such as if None then look among multple target tokens. + such as if None then look among multiple target tokens. :param passive: passive load flag passed to :func:`.loading.get_from_identity`, which impacts the behavior if the object is found; the object may be validated and/or unexpired @@ -2842,7 +2842,7 @@ class Query(object): approach to the use case of applying an :func:`.aliased` construct explicitly throughout a query. Instead of referring to the :func:`.aliased` construct explicitly, - :meth:`.Query.select_entity_from` automatically *adapts* all occurences + :meth:`.Query.select_entity_from` automatically *adapts* all occurrences of the entity to the target selectable. Given a case for :func:`.aliased` such as selecting ``User`` diff --git a/lib/sqlalchemy/orm/relationships.py b/lib/sqlalchemy/orm/relationships.py index 530a9bd89..b00d72d64 100644 --- a/lib/sqlalchemy/orm/relationships.py +++ b/lib/sqlalchemy/orm/relationships.py @@ -426,7 +426,7 @@ class RelationshipProperty(StrategizedProperty): In normal cases, the :paramref:`~.relationship.foreign_keys` parameter is **not required.** :func:`.relationship` will automatically determine which columns in the - :paramref:`~.relationship.primaryjoin` conditition are to be + :paramref:`~.relationship.primaryjoin` condition are to be considered "foreign key" columns based on those :class:`.Column` objects that specify :class:`.ForeignKey`, or are otherwise listed as referencing columns in a diff --git a/lib/sqlalchemy/orm/session.py b/lib/sqlalchemy/orm/session.py index a4cc07194..9e52ef208 100644 --- a/lib/sqlalchemy/orm/session.py +++ b/lib/sqlalchemy/orm/session.py @@ -891,7 +891,7 @@ class Session(_SessionClassMethods): not necessary for new applications. The :class:`.Session` normally handles the work of "begin" transparently, which in turn relies upon the Python DBAPI to transparently "begin" - transactions; there is **no need to explcitly begin transactions** + transactions; there is **no need to explicitly begin transactions** when using modern :class:`.Session` programming patterns. In its default mode of ``autocommit=False``, the :class:`.Session` does all of its work within @@ -2325,7 +2325,7 @@ class Session(_SessionClassMethods): To make a transient object associated with a :class:`.Session` via :meth:`.Session.enable_relationship_loading` pending, add it to the :class:`.Session` using :meth:`.Session.add` normally. - If the object instead represents an existing idenity in the database, + If the object instead represents an existing identity in the database, it should be merged using :meth:`.Session.merge`. :meth:`.Session.enable_relationship_loading` does not improve diff --git a/lib/sqlalchemy/orm/state.py b/lib/sqlalchemy/orm/state.py index b5c441458..38c3f3791 100644 --- a/lib/sqlalchemy/orm/state.py +++ b/lib/sqlalchemy/orm/state.py @@ -312,7 +312,7 @@ class InstanceState(interfaces.InspectionAttrInfo): @util.memoized_property def mapper(self): - """Return the :class:`.Mapper` used for this mapepd object.""" + """Return the :class:`.Mapper` used for this mapped object.""" return self.manager.mapper @property diff --git a/lib/sqlalchemy/orm/strategy_options.py b/lib/sqlalchemy/orm/strategy_options.py index 759efe9f5..cac23f6be 100644 --- a/lib/sqlalchemy/orm/strategy_options.py +++ b/lib/sqlalchemy/orm/strategy_options.py @@ -1472,7 +1472,7 @@ def undefer_group(loadopt, name): defaultload("someattr").undefer_group("large_attrs")) .. versionchanged:: 0.9.0 :func:`.orm.undefer_group` is now specific to a - particiular entity load path. + particular entity load path. .. seealso:: diff --git a/lib/sqlalchemy/pool/base.py b/lib/sqlalchemy/pool/base.py index 40d97515e..ea73f08d4 100644 --- a/lib/sqlalchemy/pool/base.py +++ b/lib/sqlalchemy/pool/base.py @@ -470,7 +470,7 @@ class _ConnectionRecord(object): Unlike the :attr:`._ConnectionRecord.info` dictionary, which is linked to the lifespan of the DBAPI connection, this dictionary is linked to the lifespan of the :class:`._ConnectionRecord` container itself - and will remain persisent throughout the life of the + and will remain persistent throughout the life of the :class:`._ConnectionRecord`. .. versionadded:: 1.1 diff --git a/lib/sqlalchemy/sql/ddl.py b/lib/sqlalchemy/sql/ddl.py index 954f769ef..d87a6a1b0 100644 --- a/lib/sqlalchemy/sql/ddl.py +++ b/lib/sqlalchemy/sql/ddl.py @@ -303,7 +303,7 @@ class DDL(DDLElement): connection.execute(drop_spow) When operating on Table events, the following ``statement`` - string substitions are available:: + string substitutions are available:: %(table)s - the Table name, with any required quoting applied %(schema)s - the schema name, with any required quoting applied @@ -1045,7 +1045,7 @@ def sort_tables(tables, skip_fn=None, extra_dependencies=None): automatic resolution of dependency cycles between tables, which are usually caused by mutually dependent foreign key constraints. To resolve these cycles, either the - :paramref:`.ForeignKeyConstraint.use_alter` parameter may be appled + :paramref:`.ForeignKeyConstraint.use_alter` parameter may be applied to those constraints, or use the :func:`.sql.sort_tables_and_constraints` function which will break out foreign key constraints involved in cycles separately. diff --git a/lib/sqlalchemy/sql/elements.py b/lib/sqlalchemy/sql/elements.py index 71f346f45..9e4f5d95d 100644 --- a/lib/sqlalchemy/sql/elements.py +++ b/lib/sqlalchemy/sql/elements.py @@ -1089,7 +1089,7 @@ class BindParameter(ColumnElement): if True, this parameter will be treated as an "expanding" parameter at execution time; the parameter value is expected to be a sequence, rather than a scalar value, and the string SQL statement will - be transformed on a per-execution basis to accomodate the sequence + be transformed on a per-execution basis to accommodate the sequence with a variable number of parameter slots passed to the DBAPI. This is to allow statement caching to be used in conjunction with an IN clause. diff --git a/lib/sqlalchemy/sql/operators.py b/lib/sqlalchemy/sql/operators.py index 7277787e2..4206de460 100644 --- a/lib/sqlalchemy/sql/operators.py +++ b/lib/sqlalchemy/sql/operators.py @@ -690,7 +690,7 @@ class ColumnOperators(Operators): ``"%"`` and ``"_"`` that are present inside the <other> expression will behave like wildcards as well. For literal string values, the :paramref:`.ColumnOperators.startswith.autoescape` flag - may be set to ``True`` to apply escaping to occurences of these + may be set to ``True`` to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the :paramref:`.ColumnOperators.startswith.escape` parameter will establish @@ -778,7 +778,7 @@ class ColumnOperators(Operators): ``"%"`` and ``"_"`` that are present inside the <other> expression will behave like wildcards as well. For literal string values, the :paramref:`.ColumnOperators.endswith.autoescape` flag - may be set to ``True`` to apply escaping to occurences of these + may be set to ``True`` to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the :paramref:`.ColumnOperators.endswith.escape` parameter will establish @@ -866,7 +866,7 @@ class ColumnOperators(Operators): ``"%"`` and ``"_"`` that are present inside the <other> expression will behave like wildcards as well. For literal string values, the :paramref:`.ColumnOperators.contains.autoescape` flag - may be set to ``True`` to apply escaping to occurences of these + may be set to ``True`` to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the :paramref:`.ColumnOperators.contains.escape` parameter will establish @@ -950,7 +950,7 @@ class ColumnOperators(Operators): * Oracle - renders ``CONTAINS(x, y)`` * other backends may provide special implementations. * Backends without any special implementation will emit - the operator as "MATCH". This is compatible with SQlite, for + the operator as "MATCH". This is compatible with SQLite, for example. """ diff --git a/lib/sqlalchemy/sql/schema.py b/lib/sqlalchemy/sql/schema.py index d9555b196..07c0017b9 100644 --- a/lib/sqlalchemy/sql/schema.py +++ b/lib/sqlalchemy/sql/schema.py @@ -857,7 +857,7 @@ class Table(DialectKWArgs, SchemaItem, TableClause): m1 = MetaData() - user = Table('user', m1, Column('id', Integer, priamry_key=True)) + user = Table('user', m1, Column('id', Integer, primary_key=True)) m2 = MetaData() user_copy = user.tometadata(m2) @@ -1494,7 +1494,7 @@ class Column(DialectKWArgs, SchemaItem, ColumnClause): event.listen(self, "after_parent_attach", fn) def copy(self, **kw): - """Create a copy of this ``Column``, unitialized. + """Create a copy of this ``Column``, uninitialized. This is used in ``Table.tometadata``. @@ -4028,7 +4028,7 @@ class MetaData(SchemaItem): automatic resolution of dependency cycles between tables, which are usually caused by mutually dependent foreign key constraints. To resolve these cycles, either the - :paramref:`.ForeignKeyConstraint.use_alter` parameter may be appled + :paramref:`.ForeignKeyConstraint.use_alter` parameter may be applied to those constraints, or use the :func:`.schema.sort_tables_and_constraints` function which will break out foreign key constraints involved in cycles separately. @@ -4074,7 +4074,7 @@ class MetaData(SchemaItem): the existing bind on this ``MetaData``, if any. :param schema: - Optional, query and reflect tables from an alterate schema. + Optional, query and reflect tables from an alternate schema. If None, the schema associated with this :class:`.MetaData` is used, if any. diff --git a/lib/sqlalchemy/sql/selectable.py b/lib/sqlalchemy/sql/selectable.py index f48fa6f57..a5dee068c 100644 --- a/lib/sqlalchemy/sql/selectable.py +++ b/lib/sqlalchemy/sql/selectable.py @@ -1413,7 +1413,7 @@ class Lateral(Alias): level function as well as the :meth:`.FromClause.lateral` method available on all :class:`.FromClause` subclasses. - While LATERAL is part of the SQL standard, curently only more recent + While LATERAL is part of the SQL standard, currently only more recent PostgreSQL versions provide support for this keyword. .. versionadded:: 1.1 @@ -3256,7 +3256,7 @@ class Select(HasPrefixes, HasSuffixes, GenerativeSelect): When columns are omitted based on foreign key, the referred-to column is the one that's kept. When columns are omitted based on - WHERE eqivalence, the first column in the columns clause is the + WHERE equivalence, the first column in the columns clause is the one that's kept. :param only_synonyms: when True, limit the removal of columns diff --git a/lib/sqlalchemy/sql/sqltypes.py b/lib/sqlalchemy/sql/sqltypes.py index 8131be443..8798f5ad7 100644 --- a/lib/sqlalchemy/sql/sqltypes.py +++ b/lib/sqlalchemy/sql/sqltypes.py @@ -588,7 +588,7 @@ class Numeric(_LookupExpressionAdapter, TypeEngine): be much longer due to decimal inaccuracy, and most floating point database types don't have a notion of "scale", so by default the float type looks for the first ten decimal places when converting. - Specfiying this value will override that length. Types which + Specifying this value will override that length. Types which do include an explicit ".scale" value, such as the base :class:`.Numeric` as well as the MySQL float types, will use the value of ".scale" as the default for decimal_return_scale, if not @@ -597,7 +597,7 @@ class Numeric(_LookupExpressionAdapter, TypeEngine): .. versionadded:: 0.9.0 When using the ``Numeric`` type, care should be taken to ensure - that the asdecimal setting is apppropriate for the DBAPI in use - + that the asdecimal setting is appropriate for the DBAPI in use - when Numeric applies a conversion from Decimal->float or float-> Decimal, this conversion incurs an additional performance overhead for all result columns received. @@ -739,7 +739,7 @@ class Float(Numeric): be much longer due to decimal inaccuracy, and most floating point database types don't have a notion of "scale", so by default the float type looks for the first ten decimal places when converting. - Specfiying this value will override that length. Note that the + Specifying this value will override that length. Note that the MySQL float types, which do include "scale", will use "scale" as the default for decimal_return_scale, if not otherwise specified. @@ -1962,9 +1962,9 @@ class JSON(Indexable, TypeEngine): Index operations return an expression object whose type defaults to :class:`.JSON` by default, so that further JSON-oriented instructions may be called upon the result type. Note that there are backend-specific - idiosyncracies here, including that the PostgreSQL database does not + idiosyncrasies here, including that the PostgreSQL database does not generally compare a "json" to a "json" structure without type casts. These - idiosyncracies can be accommodated in a backend-neutral way by making + idiosyncrasies can be accommodated in a backend-neutral way by making explicit use of the :func:`.cast` and :func:`.type_coerce` constructs. Comparison of specific index elements of a :class:`.JSON` object to other objects works best if the **left hand side is CAST to a string** and the diff --git a/lib/sqlalchemy/sql/type_api.py b/lib/sqlalchemy/sql/type_api.py index 2c01484eb..9e052c6b4 100644 --- a/lib/sqlalchemy/sql/type_api.py +++ b/lib/sqlalchemy/sql/type_api.py @@ -185,7 +185,7 @@ class TypeEngine(Visitable): .. note:: - The "evaulates none" flag does **not** apply to a value + The "evaluates none" flag does **not** apply to a value of ``None`` passed to :paramref:`.Column.default` or :paramref:`.Column.server_default`; in these cases, ``None`` still means "no default". @@ -218,7 +218,7 @@ class TypeEngine(Visitable): where it can be consumed by schema comparison tools such as Alembic autogenerate. - A future release of SQLAlchemy will potentially impement this method + A future release of SQLAlchemy will potentially implement this method for builtin types as well. The function should return True if this type is equivalent to the diff --git a/lib/sqlalchemy/sql/util.py b/lib/sqlalchemy/sql/util.py index 9780caa1c..5a44f873d 100644 --- a/lib/sqlalchemy/sql/util.py +++ b/lib/sqlalchemy/sql/util.py @@ -116,7 +116,7 @@ def find_left_clause_to_join_from(clauses, join_to, onclause): and optional ON clause, return a list of integer indexes from the clauses list indicating the clauses that can be joined from. - The presense of an "onclause" indicates that at least one clause can + The presence of an "onclause" indicates that at least one clause can definitely be joined from; if the list of clauses is of length one and the onclause is given, returns that index. If the list of clauses is more than length one, and the onclause is given, attempts to locate diff --git a/lib/sqlalchemy/testing/schema.py b/lib/sqlalchemy/testing/schema.py index b389ffd95..977904752 100644 --- a/lib/sqlalchemy/testing/schema.py +++ b/lib/sqlalchemy/testing/schema.py @@ -35,7 +35,7 @@ def Table(*args, **kw): kw["mysql_engine"] = "MyISAM" # Apply some default cascading rules for self-referential foreign keys. - # MySQL InnoDB has some issues around seleting self-refs too. + # MySQL InnoDB has some issues around selecting self-refs too. if exclusions.against(config._current, "firebird"): table_name = args[0] unpack = config.db.dialect.identifier_preparer.unformat_identifiers diff --git a/lib/sqlalchemy/testing/suite/test_insert.py b/lib/sqlalchemy/testing/suite/test_insert.py index 1b14e8ed8..fc535aa23 100644 --- a/lib/sqlalchemy/testing/suite/test_insert.py +++ b/lib/sqlalchemy/testing/suite/test_insert.py @@ -300,7 +300,7 @@ class ReturningTest(fixtures.TablesTest): fetched_pk = config.db.scalar(select([table.c.id])) eq_(fetched_pk, pk) - def test_autoincrement_on_insert_implcit_returning(self): + def test_autoincrement_on_insert_implicit_returning(self): config.db.execute(self.tables.autoinc_pk.insert(), data="some data") self._assert_round_trip(self.tables.autoinc_pk, config.db) diff --git a/lib/sqlalchemy/util/langhelpers.py b/lib/sqlalchemy/util/langhelpers.py index 56e1304e3..1bc3c00de 100644 --- a/lib/sqlalchemy/util/langhelpers.py +++ b/lib/sqlalchemy/util/langhelpers.py @@ -1415,7 +1415,7 @@ def warn(msg): def warn_limited(msg, args): - """Issue a warning with a paramterized string, limiting the number + """Issue a warning with a parameterized string, limiting the number of registrations. """ @@ -1525,7 +1525,7 @@ def wrap_callable(wrapper, fn): def quoted_token_parser(value): - """Parse a dotted identifier with accomodation for quoted names. + """Parse a dotted identifier with accommodation for quoted names. Includes support for SQL-style double quotes as a literal character. |