Spelling fixespr/266

5 files changed, 10 insertions, 10 deletions

diff --git a/lib/sqlalchemy/ext/associationproxy.py b/lib/sqlalchemy/ext/associationproxy.py
index fdc44f386..832680382 100644
--- a/lib/sqlalchemy/ext/associationproxy.py
+++ b/lib/sqlalchemy/ext/associationproxy.py
@@ -483,7 +483,7 @@ class _AssociationCollection(object):
 
         lazy_collection
           A callable returning a list-based collection of entities (usually an
-          object attribute managed by a SQLAlchemy relationship())
+          object attribute managed by an SQLAlchemy relationship())
 
         creator
           A function that creates new target entities.  Given one parameter:
diff --git a/lib/sqlalchemy/ext/compiler.py b/lib/sqlalchemy/ext/compiler.py
index 86156be1f..417979927 100644
--- a/lib/sqlalchemy/ext/compiler.py
+++ b/lib/sqlalchemy/ext/compiler.py
@@ -115,7 +115,7 @@ SQL and DDL constructs are each compiled using different base compilers -
 ``SQLCompiler`` and ``DDLCompiler``.   A common need is to access the
 compilation rules of SQL expressions from within a DDL expression. The
 ``DDLCompiler`` includes an accessor ``sql_compiler`` for this reason, such as
-below where we generate a CHECK constraint that embeds a SQL expression::
+below where we generate a CHECK constraint that embeds an SQL expression::
 
     @compiles(MyConstraint)
     def compile_my_constraint(constraint, ddlcompiler, **kw):
@@ -252,7 +252,7 @@ A synopsis is as follows:
           type = TIMESTAMP()
 
 * :class:`~sqlalchemy.sql.functions.FunctionElement` - This is a hybrid of a
-  ``ColumnElement`` and a "from clause" like object, and represents a SQL
+  ``ColumnElement`` and a "from clause" like object, and represents an SQL
   function or stored procedure type of call. Since most databases support
   statements along the line of "SELECT FROM <some function>"
   ``FunctionElement`` adds in the ability to be used in the FROM clause of a
diff --git a/lib/sqlalchemy/ext/horizontal_shard.py b/lib/sqlalchemy/ext/horizontal_shard.py
index 996e81fca..b625a2539 100644
--- a/lib/sqlalchemy/ext/horizontal_shard.py
+++ b/lib/sqlalchemy/ext/horizontal_shard.py
@@ -80,7 +80,7 @@ class ShardedSession(Session):
         """Construct a ShardedSession.
 
         :param shard_chooser: A callable which, passed a Mapper, a mapped
-          instance, and possibly a SQL clause, returns a shard ID.  This id
+          instance, and possibly an SQL clause, returns a shard ID.  This id
           may be based off of the attributes present within the object, or on
           some round-robin scheme. If the scheme is based on a selection, it
           should set whatever state on the instance to mark it in the future as
diff --git a/lib/sqlalchemy/ext/hybrid.py b/lib/sqlalchemy/ext/hybrid.py
index bbf386742..077df2c02 100644
--- a/lib/sqlalchemy/ext/hybrid.py
+++ b/lib/sqlalchemy/ext/hybrid.py
@@ -124,7 +124,7 @@ Defining Expression Behavior Distinct from Attribute Behavior
 Our usage of the ``&`` and ``|`` bitwise operators above was
 fortunate, considering our functions operated on two boolean values to
 return a new one.   In many cases, the construction of an in-Python
-function and a SQLAlchemy SQL expression have enough differences that
+function and an SQLAlchemy SQL expression have enough differences that
 two separate Python expressions should be defined.  The
 :mod:`~sqlalchemy.ext.hybrid` decorators define the
 :meth:`.hybrid_property.expression` modifier for this purpose.   As an
@@ -416,7 +416,7 @@ previous ``CaseInsensitiveComparator`` class with a new
         "Label to apply to Query tuple results"
 
 Above, the ``CaseInsensitiveWord`` object represents ``self.word``,
-which may be a SQL function, or may be a Python native.   By
+which may be an SQL function, or may be a Python native.   By
 overriding ``operate()`` and ``__clause_element__()`` to work in terms
 of ``self.word``, all comparison operations will work against the
 "converted" form of ``word``, whether it be SQL side or Python side.
@@ -765,7 +765,7 @@ class hybrid_property(interfaces.InspectionAttrInfo):
         return self
 
     def expression(self, expr):
-        """Provide a modifying decorator that defines a SQL-expression
+        """Provide a modifying decorator that defines an SQL-expression
         producing method."""
 
         self.expr = expr
diff --git a/lib/sqlalchemy/ext/mutable.py b/lib/sqlalchemy/ext/mutable.py
index 571bbbda3..258dc4ecf 100644
--- a/lib/sqlalchemy/ext/mutable.py
+++ b/lib/sqlalchemy/ext/mutable.py
@@ -46,7 +46,7 @@ with any type whose target Python type may be mutable, including
 :class:`.PickleType`, :class:`.postgresql.ARRAY`, etc.
 
 When using the :mod:`sqlalchemy.ext.mutable` extension, the value itself
-tracks all parents which reference it.  Below, we illustrate the a simple
+tracks all parents which reference it.  Below, we illustrate a simple
 version of the :class:`.MutableDict` dictionary object, which applies
 the :class:`.Mutable` mixin to a plain Python dictionary::
 
@@ -551,7 +551,7 @@ class Mutable(MutableBase):
 
     @classmethod
     def as_mutable(cls, sqltype):
-        """Associate a SQL type with this mutable Python type.
+        """Associate an SQL type with this mutable Python type.
 
         This establishes listeners that will detect ORM mappings against
         the given type, adding mutation event trackers to those mappings.
@@ -596,7 +596,7 @@ class Mutable(MutableBase):
 
 class MutableComposite(MutableBase):
     """Mixin that defines transparent propagation of change
-    events on a SQLAlchemy "composite" object to its
+    events on an SQLAlchemy "composite" object to its
     owning parent or parents.
 
     See the example in :ref:`mutable_composites` for usage information.