Merge pull request #46 from vrajmohan/master

More fixes for cross references and reducing warnings (3rd wave)

12 files changed, 29 insertions, 29 deletions

diff --git a/lib/sqlalchemy/dialects/oracle/cx_oracle.py b/lib/sqlalchemy/dialects/oracle/cx_oracle.py
index 60267aab9..2126ecd01 100644
--- a/lib/sqlalchemy/dialects/oracle/cx_oracle.py
+++ b/lib/sqlalchemy/dialects/oracle/cx_oracle.py
@@ -17,11 +17,11 @@ Additional Connect Arguments
 
 When connecting with ``dbname`` present, the host, port, and dbname tokens are
 converted to a TNS name using
-the cx_oracle :func:`makedsn()` function.  Otherwise, the host token is taken
+the cx_oracle ``makedsn()`` function.  Otherwise, the host token is taken
 directly as a TNS name.
 
 Additional arguments which may be specified either as query string arguments
-on the URL, or as keyword arguments to :func:`~sqlalchemy.create_engine()` are:
+on the URL, or as keyword arguments to :func:`.create_engine()` are:
 
 * allow_twophase - enable two-phase transactions.  Defaults to ``True``.
 
@@ -96,7 +96,7 @@ like result.fetchmany() and result.fetchall().   This means that by default, LOB
 objects are fully fetched unconditionally by SQLAlchemy, and the linkage to a live
 cursor is broken.
 
-To disable this processing, pass ``auto_convert_lobs=False`` to :func:`create_engine()`.
+To disable this processing, pass ``auto_convert_lobs=False`` to :func:`.create_engine()`.
 
 Two Phase Transaction Support
 -----------------------------
@@ -129,7 +129,7 @@ the application can make one of several choices:
 
 * For ad-hoc two-phase operations without disabling pooling, the DBAPI
   connection in use can be evicted from the connection pool using the
-  :class:`.Connection.detach` method.
+  :meth:`.Connection.detach` method.
 
 .. versionchanged:: 0.8.0b2,0.7.10
     Support for cx_oracle prepared transactions has been implemented
diff --git a/lib/sqlalchemy/dialects/sqlite/pysqlite.py b/lib/sqlalchemy/dialects/sqlite/pysqlite.py
index 07f96a1af..70d7a4b2e 100644
--- a/lib/sqlalchemy/dialects/sqlite/pysqlite.py
+++ b/lib/sqlalchemy/dialects/sqlite/pysqlite.py
@@ -162,8 +162,8 @@ Using Temporary Tables with SQLite
 Due to the way SQLite deals with temporary tables, if you wish to use a
 temporary table in a file-based SQLite database across multiple checkouts
 from the connection pool, such as when using an ORM :class:`.Session` where
-the temporary table should continue to remain after :meth:`.commit` or
-:meth:`.rollback` is called, a pool which maintains a single connection must
+the temporary table should continue to remain after :meth:`.Session.commit` or
+:meth:`.Session.rollback` is called, a pool which maintains a single connection must
 be used.   Use :class:`.SingletonThreadPool` if the scope is only needed
 within the current thread, or :class:`.StaticPool` is scope is needed within
 multiple threads for this case::
diff --git a/lib/sqlalchemy/events.py b/lib/sqlalchemy/events.py
index c0118dd9f..a7de37ef8 100644
--- a/lib/sqlalchemy/events.py
+++ b/lib/sqlalchemy/events.py
@@ -14,7 +14,7 @@ from .sql.base import SchemaEventTarget
 class DDLEvents(event.Events):
     """
     Define event listeners for schema objects,
-    that is, :class:`.SchemaItem` and :class:`.SchemaEvent`
+    that is, :class:`.SchemaItem` and other :class:`.SchemaEventTarget`
     subclasses, including :class:`.MetaData`, :class:`.Table`,
     :class:`.Column`.
 
diff --git a/lib/sqlalchemy/ext/declarative/__init__.py b/lib/sqlalchemy/ext/declarative/__init__.py
index c60700a02..810f89bb0 100644
--- a/lib/sqlalchemy/ext/declarative/__init__.py
+++ b/lib/sqlalchemy/ext/declarative/__init__.py
@@ -1284,7 +1284,7 @@ Sessions
 Note that ``declarative`` does nothing special with sessions, and is
 only intended as an easier way to configure mappers and
 :class:`~sqlalchemy.schema.Table` objects.  A typical application
-setup using :class:`~sqlalchemy.orm.scoped_session` might look like::
+setup using :class:`~sqlalchemy.orm.scoping.scoped_session` might look like::
 
     engine = create_engine('postgresql://scott:tiger@localhost/test')
     Session = scoped_session(sessionmaker(autocommit=False,
diff --git a/lib/sqlalchemy/ext/declarative/api.py b/lib/sqlalchemy/ext/declarative/api.py
index b309a783a..2f84896aa 100644
--- a/lib/sqlalchemy/ext/declarative/api.py
+++ b/lib/sqlalchemy/ext/declarative/api.py
@@ -174,16 +174,16 @@ def declarative_base(bind=None, metadata=None, mapper=None, cls=object,
     of the class.
 
     :param bind: An optional
-      :class:`~sqlalchemy.engine.base.Connectable`, will be assigned
-      the ``bind`` attribute on the :class:`~sqlalchemy.MetaData`
+      :class:`~sqlalchemy.engine.Connectable`, will be assigned
+      the ``bind`` attribute on the :class:`~sqlalchemy.schema.MetaData`
       instance.
 
     :param metadata:
-      An optional :class:`~sqlalchemy.MetaData` instance.  All
+      An optional :class:`~sqlalchemy.schema.MetaData` instance.  All
       :class:`~sqlalchemy.schema.Table` objects implicitly declared by
       subclasses of the base will share this MetaData.  A MetaData instance
       will be created if none is provided.  The
-      :class:`~sqlalchemy.MetaData` instance will be available via the
+      :class:`~sqlalchemy.schema.MetaData` instance will be available via the
       `metadata` attribute of the generated declarative base class.
 
     :param mapper:
@@ -286,7 +286,7 @@ class ConcreteBase(object):
     function automatically, against all tables mapped as a subclass
     to this class.   The function is called via the
     ``__declare_last__()`` function, which is essentially
-    a hook for the :func:`.MapperEvents.after_configured` event.
+    a hook for the :meth:`.after_configured` event.
 
     :class:`.ConcreteBase` produces a mapped
     table for the class itself.  Compare to :class:`.AbstractConcreteBase`,
@@ -341,7 +341,7 @@ class AbstractConcreteBase(ConcreteBase):
     function automatically, against all tables mapped as a subclass
     to this class.   The function is called via the
     ``__declare_last__()`` function, which is essentially
-    a hook for the :func:`.MapperEvents.after_configured` event.
+    a hook for the :meth:`.after_configured` event.
 
     :class:`.AbstractConcreteBase` does not produce a mapped
     table for the class itself.  Compare to :class:`.ConcreteBase`,
@@ -421,7 +421,7 @@ class DeferredReflection(object):
     Above, ``MyClass`` is not yet mapped.   After a series of
     classes have been defined in the above fashion, all tables
     can be reflected and mappings created using
-    :meth:`.DeferredReflection.prepare`::
+    :meth:`.prepare`::
 
         engine = create_engine("someengine://...")
         DeferredReflection.prepare(engine)
diff --git a/lib/sqlalchemy/ext/instrumentation.py b/lib/sqlalchemy/ext/instrumentation.py
index 714a76e68..2cf36e9bd 100644
--- a/lib/sqlalchemy/ext/instrumentation.py
+++ b/lib/sqlalchemy/ext/instrumentation.py
@@ -22,7 +22,7 @@ see the example :ref:`examples_instrumentation`.
    :mod:`sqlalchemy.orm.instrumentation` so that it
    takes effect, including recognition of
    ``__sa_instrumentation_manager__`` on mapped classes, as
-   well :attr:`.instrumentation_finders`
+   well :data:`.instrumentation_finders`
    being used to determine class instrumentation resolution.
 
 """
diff --git a/lib/sqlalchemy/ext/mutable.py b/lib/sqlalchemy/ext/mutable.py
index 5458de381..37c599e1d 100644
--- a/lib/sqlalchemy/ext/mutable.py
+++ b/lib/sqlalchemy/ext/mutable.py
@@ -9,7 +9,7 @@ which are propagated into ORM change events on owning parent objects.
 
 The :mod:`sqlalchemy.ext.mutable` extension replaces SQLAlchemy's legacy
 approach to in-place mutations of scalar values, established by the
-:class:`.types.MutableType` class as well as the ``mutable=True`` type flag,
+``types.MutableType`` class as well as the ``mutable=True`` type flag,
 with a system that allows change events to be propagated from the value to
 the owning parent, thereby removing the need for the ORM to maintain copies
 of values as well as the very expensive requirement of scanning through all
@@ -182,7 +182,7 @@ callbacks. In our case, this is a good thing, since if this dictionary were
 picklable, it could lead to an excessively large pickle size for our value
 objects that are pickled by themselves outside of the context of the parent.
 The developer responsibility here is only to provide a ``__getstate__`` method
-that excludes the :meth:`~.MutableBase._parents` collection from the pickle
+that excludes the :meth:`~MutableBase._parents` collection from the pickle
 stream::
 
     class MyMutableType(Mutable):
@@ -332,7 +332,7 @@ Supporting Pickling
 
 As is the case with :class:`.Mutable`, the :class:`.MutableComposite` helper
 class uses a ``weakref.WeakKeyDictionary`` available via the
-:meth:`.MutableBase._parents` attribute which isn't picklable. If we need to
+:meth:`MutableBase._parents` attribute which isn't picklable. If we need to
 pickle instances of ``Point`` or its owning class ``Vertex``, we at least need
 to define a ``__getstate__`` that doesn't include the ``_parents`` dictionary.
 Below we define both a ``__getstate__`` and a ``__setstate__`` that package up
@@ -349,7 +349,7 @@ the minimal form of our ``Point`` class::
 
 As with :class:`.Mutable`, the :class:`.MutableComposite` augments the
 pickling process of the parent's object-relational state so that the
-:meth:`.MutableBase._parents` collection is restored to all ``Point`` objects.
+:meth:`MutableBase._parents` collection is restored to all ``Point`` objects.
 
 """
 from ..orm.attributes import flag_modified
@@ -542,7 +542,7 @@ class Mutable(MutableBase):
 
         To associate a particular mutable type with all occurrences of a
         particular type, use the :meth:`.Mutable.associate_with` classmethod
-        of the particular :meth:`.Mutable` subclass to establish a global
+        of the particular :class:`.Mutable` subclass to establish a global
         association.
 
         .. warning::
diff --git a/lib/sqlalchemy/orm/events.py b/lib/sqlalchemy/orm/events.py
index 855841408..d34e2395b 100644
--- a/lib/sqlalchemy/orm/events.py
+++ b/lib/sqlalchemy/orm/events.py
@@ -1116,7 +1116,7 @@ class SessionEvents(event.Events):
 
     The :func:`~.event.listen` function will accept
     :class:`.Session` objects as well as the return result
-    of :func:`.sessionmaker` and :func:`.scoped_session`.
+    of :class:`~.sessionmaker()` and :class:`~.scoped_session()`.
 
     Additionally, it accepts the :class:`.Session` class which
     will apply listeners to all :class:`.Session` instances
@@ -1203,7 +1203,7 @@ class SessionEvents(event.Events):
 
         .. note::
 
-            The :meth:`.before_commit` hook is *not* per-flush,
+            The :meth:`~.SessionEvents.before_commit` hook is *not* per-flush,
             that is, the :class:`.Session` can emit SQL to the database
             many times within the scope of a transaction.
             For interception of these events, use the :meth:`~.SessionEvents.before_flush`,
@@ -1389,7 +1389,7 @@ class SessionEvents(event.Events):
         This is called before an add, delete or merge causes
         the object to be part of the session.
 
-        .. versionadded:: 0.8.  Note that :meth:`.after_attach` now
+        .. versionadded:: 0.8.  Note that :meth:`~.SessionEvents.after_attach` now
            fires off after the item is part of the session.
            :meth:`.before_attach` is provided for those cases where
            the item should not yet be part of the session state.
@@ -1504,7 +1504,7 @@ class AttributeEvents(event.Events):
         listen(UserContact.phone, 'set', validate_phone, retval=True)
 
     A validation function like the above can also raise an exception
-    such as :class:`.ValueError` to halt the operation.
+    such as :exc:`ValueError` to halt the operation.
 
     Several modifiers are available to the :func:`~.event.listen` function.
 
diff --git a/lib/sqlalchemy/orm/session.py b/lib/sqlalchemy/orm/session.py
index 217686268..6d4b23988 100644
--- a/lib/sqlalchemy/orm/session.py
+++ b/lib/sqlalchemy/orm/session.py
@@ -823,7 +823,7 @@ class Session(_SessionClassMethods):
             etc.) which will be used to locate a bind, if a bind
             cannot otherwise be identified.
 
-        :param close_with_result: Passed to :meth:`Engine.connect`, indicating
+        :param close_with_result: Passed to :meth:`.Engine.connect`, indicating
           the :class:`.Connection` should be considered "single use",
           automatically closing when the first result set is closed.  This
           flag only has an effect if this :class:`.Session` is configured with
diff --git a/lib/sqlalchemy/orm/strategy_options.py b/lib/sqlalchemy/orm/strategy_options.py
index 72dafb472..5991f2dc1 100644
--- a/lib/sqlalchemy/orm/strategy_options.py
+++ b/lib/sqlalchemy/orm/strategy_options.py
@@ -619,7 +619,7 @@ def joinedload(loadopt, attr, innerjoin=None):
         :class:`.Query` refer to these joins in any way, including ordering.
 
         To produce a specific SQL JOIN which is explicitly available, use
-        :class:`.Query.join`.   To combine explicit JOINs with eager loading
+        :meth:`.Query.join`.   To combine explicit JOINs with eager loading
         of collections, use :func:`.orm.contains_eager`; see :ref:`contains_eager`.
 
     .. seealso::
diff --git a/lib/sqlalchemy/sql/selectable.py b/lib/sqlalchemy/sql/selectable.py
index 11638b0ae..b850e1465 100644
--- a/lib/sqlalchemy/sql/selectable.py
+++ b/lib/sqlalchemy/sql/selectable.py
@@ -1950,7 +1950,7 @@ class Select(HasPrefixes, GenerativeSelect):
           to set the autocommit option.
 
         :param bind=None:
-          an :class:`~.base.Engine` or :class:`~.base.Connection` instance
+          an :class:`~.Engine` or :class:`~.Connection` instance
           to which the
           resulting :class:`.Select` object will be bound.  The :class:`.Select`
           object will otherwise automatically bind to whatever
diff --git a/lib/sqlalchemy/sql/sqltypes.py b/lib/sqlalchemy/sql/sqltypes.py
index 7c9a65166..1c475a28b 100644
--- a/lib/sqlalchemy/sql/sqltypes.py
+++ b/lib/sqlalchemy/sql/sqltypes.py
@@ -119,7 +119,7 @@ class String(Concatenable, TypeEngine):
           unicode objects, this flag generally does not
           need to be set.  For columns that are explicitly
           intended to store non-ASCII data, the :class:`.Unicode`
-          or :class:`UnicodeText`
+          or :class:`.UnicodeText`
           types should be used regardless, which feature
           the same behavior of ``convert_unicode`` but
           also indicate an underlying column type that