Current File : //opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyo
�
��4]c @ s� d Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z d d l m Z
d d
l m Z d d l m
Z
d d l m Z e j d
� � Z d e f d � � YZ d S( s� Provides an abstraction for obtaining database schema information.
Usage Notes:
Here are some general conventions when accessing the low level inspector
methods such as get_table_names, get_columns, etc.
1. Inspector methods return lists of dicts in most cases for the following
reasons:
* They're both standard types that can be serialized.
* Using a dict instead of a tuple allows easy expansion of attributes.
* Using a list for the outer structure maintains order and is easy to work
with (e.g. list comprehension [d['name'] for d in cols]).
2. Records that contain a name, such as the column name in a column record
use the key 'name'. So for most return values, each record will have a
'name' attribute..
i ( t Connectablei ( t exc( t
inspection( t sql( t util( t operators( t schema( t
TypeEngine( t
deprecated( t topologicalc O s� | j d d � } | d k r1 | | | | | � S| j t d � | D� � t d � | j � D� � f } | j | � } | d k r� | | | | | � } | | | <n | S( Nt
info_cachec s s' | ] } t | t j � r | Vq d S( N( t
isinstanceR t string_types( t .0t a( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys <genexpr>/ s c s sA | ]7 \ } } t | t j t j t f � r | | f Vq d S( N( R R R t int_typest float( R
t kt v( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys <genexpr>1 s ( t gett Nonet __name__t tuplet items( t fnt selft cont argst kwR
t keyt ret( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt cache( s
t Inspectorc B s� e Z d Z d � Z e d � � Z e j e � d � � Z e
d � � Z d � Z e
j d d' � d( d( d � � Z d( d
� Z d � Z d � Z d( d
� Z d( d � Z d( d � Z d( d � Z e d d � d( d � � Z d( d � Z d( d � Z d( d � Z d( d � Z d( d � Z d( d � Z d) e d( d � Z! d � Z" d � Z# d � Z$ d � Z% d e& j' f d e& j( f d! e& j) f d" e& j* f g Z+ d# � Z, d$ � Z- d% � Z. d& � Z/ RS(* sm Performs database schema inspection.
The Inspector acts as a proxy to the reflection methods of the
:class:`~sqlalchemy.engine.interfaces.Dialect`, providing a
consistent interface as well as caching support for previously
fetched metadata.
A :class:`.Inspector` object is usually created via the
:func:`.inspect` function::
from sqlalchemy import inspect, create_engine
engine = create_engine('...')
insp = inspect(engine)
The inspection method above is equivalent to using the
:meth:`.Inspector.from_engine` method, i.e.::
engine = create_engine('...')
insp = Inspector.from_engine(engine)
Where above, the :class:`~sqlalchemy.engine.interfaces.Dialect` may opt
to return an :class:`.Inspector` subclass that provides additional
methods specific to the dialect's target database.
c C sn | | _ t | d � r' | j | _ n | | _ | j | k rR | j � j � n | j j | _ i | _ d S( sj Initialize a new :class:`.Inspector`.
:param bind: a :class:`~sqlalchemy.engine.Connectable`,
which is typically an instance of
:class:`~sqlalchemy.engine.Engine` or
:class:`~sqlalchemy.engine.Connection`.
For a dialect-specific instance of :class:`.Inspector`, see
:meth:`.Inspector.from_engine`
t engineN( t bindt hasattrR! t connectt closet dialectR
( R R" ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt __init__X s
c C s, t | j d � r" | j j | � St | � S( s� Construct a new dialect-specific Inspector object from the given
engine or connection.
:param bind: a :class:`~sqlalchemy.engine.Connectable`,
which is typically an instance of
:class:`~sqlalchemy.engine.Engine` or
:class:`~sqlalchemy.engine.Connection`.
This method differs from direct a direct constructor call of
:class:`.Inspector` in that the
:class:`~sqlalchemy.engine.interfaces.Dialect` is given a chance to
provide a dialect-specific :class:`.Inspector` instance, which may
provide additional methods.
See the example at :class:`.Inspector`.
t inspector( R# R& R( R ( t clsR" ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt from_enginet s c C s
t j | � S( N( R R* ( R" ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt _insp� s c C s
| j j S( s� Return the default schema name presented by the dialect
for the current engine's database user.
E.g. this is typically ``public`` for PostgreSQL and ``dbo``
for SQL Server.
( R& t default_schema_name( R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR, � s c C s2 t | j d � r. | j j | j d | j �Sg S( s! Return all schema names.
t get_schema_namesR
( R# R& R- R" R
( R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR- � s t order_bys 1.0s� The :paramref:`get_table_names.order_by` parameter is deprecated and will be removed in a future release. Please refer to :meth:`.Inspector.get_sorted_table_and_fkc_names` for a more comprehensive solution to resolving foreign key cycles between tables.c C s� t | j d � r6 | j j | j | d | j �} n | j j | � } | d k r� g } xU | D]M } xD | j | | � D]0 } | | d k rz | j | d | f � qz qz Wqa Wt t
j | | � � } n | S( s� Return all table names in referred to within a particular schema.
The names are expected to be real tables only, not views.
Views are instead returned using the :meth:`.Inspector.get_view_names`
method.
:param schema: Schema name. If ``schema`` is left at ``None``, the
database's default schema is
used, else the named schema is searched. If the database does not
support named schemas, behavior is undefined if ``schema`` is not
passed as ``None``. For special quoting, use :class:`.quoted_name`.
:param order_by: Optional, may be the string "foreign_key" to sort
the result on foreign key dependencies. Does not automatically
resolve cycles, and will raise :class:`.CircularDependencyError`
if cycles exist.
.. seealso::
:meth:`.Inspector.get_sorted_table_and_fkc_names`
:attr:`.MetaData.sorted_tables`
t get_table_namesR
t foreign_keyt referred_table( R# R& R/ R" R
R! t table_namest get_foreign_keyst appendt listR t sort( R R R. t tnamest tuplest tnamet fkey( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR/ � s %
"c s� t | j d � r6 | j j | j | d | j �} n | j j | � } t � } t � } i } x� | D]z } | j | | � } t g | D] } | d ^ q� � | | <x8 | D]0 } | | d k r� | j | d | f � q� q� Wqg Wy t
t j | | � � }
Wnt t
j k
rw} xC | j D]8 � | j � � | j � f d � | � d D� � q Wt
t j | | � � }
n Xg |
D] } | | | j | � f ^ qd t
| � f g S( sx Return dependency-sorted table and foreign key constraint names in
referred to within a particular schema.
This will yield 2-tuples of
``(tablename, [(tname, fkname), (tname, fkname), ...])``
consisting of table names in CREATE order grouped with the foreign key
constraint names that are not detected as belonging to a cycle.
The final element
will be ``(None, [(tname, fkname), (tname, fkname), ..])``
which will consist of remaining
foreign key constraint names that would require a separate CREATE
step after-the-fact, based on dependencies between tables.
.. versionadded:: 1.0.-
.. seealso::
:meth:`.Inspector.get_table_names`
:func:`.sort_tables_and_constraints` - similar method which works
with an already-given :class:`.MetaData`.
R/ R
t nameR1 c 3 s | ] } � d | f Vq d S( i N( ( R
t fkc( t edge( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys <genexpr> s i N( R# R& R/ R" R
R! R2 t setR3 t addR5 R R6 R t CircularDependencyErrort edgest removet updatet
differenceR ( R R R7 R8 t remaining_fkcst fknames_for_tableR9 t fkeyst fkR: t candidate_sortt err( ( R= sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt get_sorted_table_and_fkc_names� s0
'
"
# &c C s | j j | j d | j �S( s� return a list of temporary table names for the current bind.
This method is unsupported by most dialects; currently
only SQLite implements it.
.. versionadded:: 1.0.0
R
( R& t get_temp_table_namesR" R
( R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRL s c C s | j j | j d | j �S( s� return a list of temporary view names for the current bind.
This method is unsupported by most dialects; currently
only SQLite implements it.
.. versionadded:: 1.0.0
R
( R& t get_temp_view_namesR" R
( R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRM s c K s; t | j d � r7 | j j | j | | d | j | �Si S( s� Return a dictionary of options specified when the table of the
given name was created.
This currently includes some options that apply to MySQL tables.
:param table_name: string name of the table. For special quoting,
use :class:`.quoted_name`.
:param schema: string schema name; if omitted, uses the default schema
of the database connection. For special quoting,
use :class:`.quoted_name`.
t get_table_optionsR
( R# R& RN R" R
( R t
table_nameR R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRN * s c C s | j j | j | d | j �S( s� Return all view names in `schema`.
:param schema: Optional, retrieve names from a non-default schema.
For special quoting, use :class:`.quoted_name`.
R
( R& t get_view_namesR" R
( R R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRP > s c C s" | j j | j | | d | j �S( s� Return definition for `view_name`.
:param schema: Optional, retrieve names from a non-default schema.
For special quoting, use :class:`.quoted_name`.
R
( R& t get_view_definitionR" R
( R t view_nameR ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRQ J s c K se | j j | j | | d | j | �} x7 | D]/ } | d } t | t � s. | � | d <q. q. W| S( s� Return information about columns in `table_name`.
Given a string `table_name` and an optional string `schema`, return
column information as a list of dicts with these keys:
* ``name`` - the column's name
* ``type`` - the type of this column; an instance of
:class:`~sqlalchemy.types.TypeEngine`
* ``nullable`` - boolean flag if the column is NULL or NOT NULL
* ``default`` - the column's server default value - this is returned
as a string SQL expression.
* ``attrs`` - dict containing optional column attributes
:param table_name: string name of the table. For special quoting,
use :class:`.quoted_name`.
:param schema: string schema name; if omitted, uses the default schema
of the database connection. For special quoting,
use :class:`.quoted_name`.
:return: list of dictionaries, each representing the definition of
a database column.
R
t type( R& t get_columnsR" R
R R ( R RO R R t col_defst col_deft coltype( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRT V s
s 0.7s� The :meth:`.Inspector.get_primary_keys` method is deprecated and will be removed in a future release. Please refer to the :meth:`.Inspector.get_pk_constraint` method.c K s) | j j | j | | d | j | �d S( s� Return information about primary keys in `table_name`.
Given a string `table_name`, and an optional string `schema`, return
primary key information as a list of column names.
R
t constrained_columns( R& t get_pk_constraintR" R
( R RO R R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt get_primary_keys~ s
c K s% | j j | j | | d | j | �S( s� Return information about primary key constraint on `table_name`.
Given a string `table_name`, and an optional string `schema`, return
primary key information as a dictionary with these keys:
constrained_columns
a list of column names that make up the primary key
name
optional name of the primary key constraint.
:param table_name: string name of the table. For special quoting,
use :class:`.quoted_name`.
:param schema: string schema name; if omitted, uses the default schema
of the database connection. For special quoting,
use :class:`.quoted_name`.
R
( R& RY R" R
( R RO R R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRY � s c K s% | j j | j | | d | j | �S( s� Return information about foreign_keys in `table_name`.
Given a string `table_name`, and an optional string `schema`, return
foreign key information as a list of dicts with these keys:
constrained_columns
a list of column names that make up the foreign key
referred_schema
the name of the referred schema
referred_table
the name of the referred table
referred_columns
a list of column names in the referred table that correspond to
constrained_columns
name
optional name of the foreign key constraint.
:param table_name: string name of the table. For special quoting,
use :class:`.quoted_name`.
:param schema: string schema name; if omitted, uses the default schema
of the database connection. For special quoting,
use :class:`.quoted_name`.
R
( R& R3 R" R
( R RO R R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR3 � s c K s% | j j | j | | d | j | �S( s� Return information about indexes in `table_name`.
Given a string `table_name` and an optional string `schema`, return
index information as a list of dicts with these keys:
name
the index's name
column_names
list of column names in order
unique
boolean
column_sorting
optional dict mapping column names to tuple of sort keywords,
which may include ``asc``, ``desc``, ``nullsfirst``, ``nullslast``.
.. versionadded:: 1.3.5
dialect_options
dict of dialect-specific index options. May not be present
for all dialects.
.. versionadded:: 1.0.0
:param table_name: string name of the table. For special quoting,
use :class:`.quoted_name`.
:param schema: string schema name; if omitted, uses the default schema
of the database connection. For special quoting,
use :class:`.quoted_name`.
R
( R& t get_indexesR" R
( R RO R R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR[ � s $ c K s% | j j | j | | d | j | �S( so Return information about unique constraints in `table_name`.
Given a string `table_name` and an optional string `schema`, return
unique constraint information as a list of dicts with these keys:
name
the unique constraint's name
column_names
list of column names in order
:param table_name: string name of the table. For special quoting,
use :class:`.quoted_name`.
:param schema: string schema name; if omitted, uses the default schema
of the database connection. For special quoting,
use :class:`.quoted_name`.
R
( R& t get_unique_constraintsR" R
( R RO R R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR\ � s c K s% | j j | j | | d | j | �S( s� Return information about the table comment for ``table_name``.
Given a string ``table_name`` and an optional string ``schema``,
return table comment information as a dictionary with these keys:
text
text of the comment.
Raises ``NotImplementedError`` for a dialect that does not support
comments.
.. versionadded:: 1.2
R
( R& t get_table_commentR" R
( R RO R R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR] s c K s% | j j | j | | d | j | �S( s� Return information about check constraints in `table_name`.
Given a string `table_name` and an optional string `schema`, return
check constraint information as a list of dicts with these keys:
name
the check constraint's name
sqltext
the check constraint's SQL expression
:param table_name: string name of the table. For special quoting,
use :class:`.quoted_name`.
:param schema: string schema name; if omitted, uses the default schema
of the database connection. For special quoting,
use :class:`.quoted_name`.
.. versionadded:: 1.1.0
R
( R& t get_check_constraintsR" R
( R RO R R ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR^ s c s | d k r, � | k r d S| j � � n | j j } | j j � � } � j } t � f d � | j D� � } | j | | � j � }
|
r� � j
|
� n t j r� t
| t � r� | j | j � } n t
| t � r� | j | j � } q� n t } i } x? | j | | � j � D]% }
t } | j � |
| | | � qW| s]t j � j � � n | j | | � | | � | j | | � | | | | | � | j | | � | | | | � | j | | � | | | | � | j | | � | | | | � | j | | � | � d S( s Given a Table object, load its internal constructs based on
introspection.
This is the underlying method used by most dialects to produce
table reflection. Direct usage is like::
from sqlalchemy import create_engine, MetaData, Table
from sqlalchemy.engine.reflection import Inspector
engine = create_engine('...')
meta = MetaData()
user_table = Table('user', meta)
insp = Inspector.from_engine(engine)
insp.reflecttable(user_table, None)
:param table: a :class:`~sqlalchemy.schema.Table` instance.
:param include_columns: a list of string column names to include
in the reflection process. If ``None``, all columns are reflected.
Nc 3 s6 | ], } | � j k r | � j j | � f Vq d S( N( t dialect_kwargsR ( R
R ( t table( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys <genexpr>h s ( R R? R" R& t schema_for_objectR; t dictt reflection_optionsRN R_ t _validate_dialect_kwargsR t py2kR t strt decodet encodingt FalseRT t Truet _reflect_columnR t NoSuchTableErrort _reflect_pkt _reflect_fkt _reflect_indexest _reflect_unique_constraintst _reflect_check_constraintst _reflect_table_comment( R R` t include_columnst exclude_columnst resolve_fkst
_extend_onR& R RO Rc t tbl_optst found_tablet cols_by_orig_namet col_d( ( R` sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt reflecttable: s� c
s� � d } | j j | | � � � d } | r< | | k sN | rR | | k rR d S� d } t � f d � d d d d d d g D� � } d
� k r� | j � d
� n g }
� j d � d k rC� d } t | t j j � r� t
j | d t �} n7 t | t
j
� s3t
j t j � d � d t �} n |
j | � n d
� k rb| j � |
� n t
j | | |
| � | | <} | j | j k r�t | _ n | j | � d S( NR; RS c 3 s+ | ]! } | � k r | � | f Vq d S( N( ( R
R ( Rz ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pys <genexpr>� s t nullablet
autoincrementt quotet infoR t commentt dialect_optionst defaultt
_reflectedt sequence( t dispatcht column_reflectRb RC R R R R t elementst
TextClauset sa_schemat
DefaultClauseRj t FetchedValuet textR4 t _reflect_col_sequencet ColumnR t primary_keyt
append_column(
R R` Rz Rs Rt Ry t orig_nameR; RW t col_kwt colargsR� t col( ( Rz sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRk � sB
c C s{ d | k rw | d } t j | d d d � } d | k rK | d | _ n d | k rg | d | _ n | j | � n d S( NR� R; i t startt increment( R� t SequenceR� R� R4 ( R Rz R� t seqR� ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR� � s
c C s� | j | | | j � } | r g | d D]( } | | k r) | | k r) | | ^ q) } | j d � | j _ | j j | � n d S( NRX R; ( RY R_ R R� R; t _reload( R RO R R` Ry Rt t pk_const pkt pk_cols( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRm s (c
C s� | j | | | j � } x�| D]�}
|
d } g |
d D]% } | | k rY | | j n | ^ q: }
| r� t |
� j | � r� q n |
d } |
d } |
d } g } | d k r#| r� t j | | j d t d | d | j
d | | �n x� | D]% } | j d
j | | | g � � q� Wnj | r`t j | | j d t d | j
d t j
d | | �n x* | D]" } | j d
j | | g � � qgWd |
k r�|
d } n i } | j t j |
| | d t | �� q Wd S(
NR; RX t referred_schemaR1 t referred_columnst autoloadR t
autoload_withRv t .t optionst link_to_name( R3 R_ R R> t intersectionR R� t Tablet metadataRj R" R4 t joint BLANK_SCHEMAt append_constraintt ForeignKeyConstraint( R RO R R` Ry Rt Ru Rv Rc RG t fkey_dt connamet cRX R� R1 R� t refspect columnR� ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRn s^
3
t asct desct
nullsfirstt nullslastc
C s� | j | | � } x�| D]�} | d }
| d } | j d i � } | d }
| j d d � } | j d i � } | j d � } | r� t | � j | � r� t j d | d
j | � f � q n | r� q n g } x� | D]� } y' | | k r� | | n
| j | } Wn. t k
r:t j d | | | f � q� n X| j | d
� } x2 | j D]' \ } } | | k rW| | � } qWqWW| j
| � q� Wt j |
d | | t
t | j � � d |
f g � �q Wd S( NR; t column_namest column_sortingt uniqueRS t indexR� t duplicates_constraints5 Omitting %s key for (%s), key covers omitted columns.s , s5 %s key '%s' was not located in columns for table '%s't _table( ( R[ R R> t issubsetR t warnR� R� t KeyErrort _index_sort_exprsR4 R� t IndexRb R5 R ( R RO R R` Ry Rs Rt Rc t indexest index_dR; t columnsR� R� t flavorR� t
duplicatest idx_colsR� t idx_colt c_sortingR t op( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRo g sF
c C s= y | j | | � } Wn t k
r* d SXx | D]} | d }
| d } | j d � } | r� t | � j | � r� t j d d j | � � q2 n | r� q2 n g }
xm | D]e } y' | | k r� | | n
| j | } Wn( t k
rt j d | | f � q� X|
j
| � q� W| j t j
d |
|
� � q2 Wd S( NR; R� t duplicates_indexsD Omitting unique constraint key for (%s), key covers omitted columns.s , sD unique constraint key '%s' was not located in columns for table '%s'( R\ t NotImplementedErrorR R> R� R R� R� R� R� R4 R� R� t UniqueConstraint( R RO R R` Ry Rs Rt Rc t constraintst const_dR� R� R� t constrained_colsR� t constrained_col( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRp � s6
c
C sV y | j | | � } Wn t k
r* d SXx$ | D] } | j t j | � � q2 Wd S( N( R^ R� R� R� t CheckConstraint(
R RO R R` Ry Rs Rt Rc R� R� ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRq � s
c C sD y | j | | � } Wn t k
r* d SX| j d d � | _ d S( NR� ( R] R� R R R� ( R RO R R` Rc t comment_dict( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyRr � s
( s 1.0s� The :paramref:`get_table_names.order_by` parameter is deprecated and will be removed in a future release. Please refer to :meth:`.Inspector.get_sorted_table_and_fkc_names` for a more comprehensive solution to resolving foreign key cycles between tables.N( (0 R t
__module__t __doc__R' t classmethodR* R t _inspectsR R+ t propertyR, R- R t deprecated_paramsR R/ RK RL RM RN RP RQ RT R RZ RY R3 R[ R\ R] R^ Rj R{ Rk R� Rm Rn R t asc_opt desc_opt
nullsfirst_opt nullslast_opR� Ro Rp Rq Rr ( ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyR = sT
* 8
( # ( � 9 I : 3 N( R� t baseR t R R R R R R R� t sql.type_apiR R R t decoratorR t objectR ( ( ( sO /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/engine/reflection.pyt <module> s
Mini Shell