Commits

diana  committed 01ccebb

typos in lib/sqlalchemy/engine

  • Participants
  • Parent commits 053f669

Comments (0)

Files changed (3)

File lib/sqlalchemy/engine/base.py

     def construct_params(self, params=None):
         """Return the bind params for this compiled object.
 
-        :param params: a dict of string/object pairs whos values will
+        :param params: a dict of string/object pairs whose values will
                        override bind values compiled in to the
                        statement.
         """
           :ref:`postgresql_toplevel` - see those dialect's documentation
           for further info.
 
-          Note that this option necessarily affects the underying 
+          Note that this option necessarily affects the underlying 
           DBAPI connection for the lifespan of the originating 
           :class:`.Connection`, and is not per-execution. This 
-          setting is not removed until the underying DBAPI connection 
+          setting is not removed until the underlying DBAPI connection 
           is returned to the connection pool, i.e.
           the :meth:`.Connection.close` method is called.
 
         """Returns self.
 
         This ``Connectable`` interface method returns self, allowing
-        Connections to be used interchangably with Engines in most
+        Connections to be used interchangeably with Engines in most
         situations that require a bind.
         """
 
         """Returns self.
 
         This ``Connectable`` interface method returns self, allowing
-        Connections to be used interchangably with Engines in most
+        Connections to be used interchangeably with Engines in most
         situations that require a bind.
         """
 
     def detach(self):
         """Detach the underlying DB-API connection from its connection pool.
 
-        This Connection instance will remain useable.  When closed,
+        This Connection instance will remain usable.  When closed,
         the DB-API connection will be literally closed and not
         returned to its pool.  The pool will typically lazily create a
         new connection to replace the detached connection.
     :class:`~sqlalchemy.engine.base.Dialect` together to provide a source 
     of database connectivity and behavior.
 
-    An :class:`.Engine` object is instantiated publically using the 
+    An :class:`.Engine` object is instantiated publicly using the 
     :func:`~sqlalchemy.create_engine` function.
 
     See also:
         The given keys/values in \**opt are added to the
         default execution options that will be used for 
         all connections.  The initial contents of this dictionary
-        can be sent via the ``execution_options`` paramter
+        can be sent via the ``execution_options`` parameter
         to :func:`.create_engine`.
 
         See :meth:`.Connection.execution_options` for more

File lib/sqlalchemy/engine/default.py

         return insp.reflecttable(table, include_columns, exclude_columns)
 
     def get_pk_constraint(self, conn, table_name, schema=None, **kw):
-        """Compatiblity method, adapts the result of get_primary_keys()
+        """Compatibility method, adapts the result of get_primary_keys()
         for those dialects which don't implement get_pk_constraint().
 
         """
         return False
 
     def reset_isolation_level(self, dbapi_conn):
-        # default_isolation_level is read from the first conenction 
+        # default_isolation_level is read from the first connection 
         # after the initial set of 'isolation_level', if any, so is 
         # the configured default of this dialect.
         self.set_isolation_level(dbapi_conn, self.default_isolation_level)

File lib/sqlalchemy/engine/strategies.py

 
 
 class EngineStrategy(object):
-    """An adaptor that processes input arguements and produces an Engine.
+    """An adaptor that processes input arguments and produces an Engine.
 
     Provides a ``create`` method that receives input arguments and
     produces an instance of base.Engine or a subclass.
 
 
 class DefaultEngineStrategy(EngineStrategy):
-    """Base class for built-in stratgies."""
+    """Base class for built-in strategies."""
 
     def create(self, name_or_url, **kwargs):
         # create url.URL object
 
 
 class ThreadLocalEngineStrategy(DefaultEngineStrategy):
-    """Strategy for configuring an Engine with thredlocal behavior."""
+    """Strategy for configuring an Engine with threadlocal behavior."""
 
     name = 'threadlocal'
     engine_cls = threadlocal.TLEngine