Why Gemfury?
Push, build, and install
RubyGems
npm packages
Python packages
Maven artifacts
PHP packages
Go Modules
Debian packages
RPM packages
NuGet packages
triliodata-4-0-patch / contego deb
Repository URL to install this package:
|
Version:
4.0.108 ▾
|
ó
EYc @ sS d d l m Z m Z m Z m Z m Z d d l m Z m Z m Z d d l
m Z m Z d d l m
Z
d d l Z d d l m Z m Z m Z m Z m Z m Z m Z m Z m Z d d l m Z m Z d d
l m Z d d l m Z e d/ Z d e f d YZ d Z! d e" d Z# d Z$ d e j% f d YZ& d e' f d YZ( d e f d YZ) e j* e( d e j* e) d! d d e, e, d" Z- e, e, d e, e, e, d d# Z. d d$ Z/ d% Z0 d& Z1 d' e j2 f d( YZ3 d e, d d) Z4 d d d* Z5 d+ Z6 d, Z7 d- Z8 d. Z9 d S(0 i ( t sqlt utilt eventt exct
inspection( t
expressionR t operatorsi ( t PropComparatort MapperProperty( t
attributesiÿÿÿÿN( t instance_strt state_strt state_class_strt
attribute_strt state_attribute_strt
object_mappert object_statet _none_sett
_never_set( t class_mappert _class_to_mapper( t InspectionAttr( t PathRegistryt deletes
delete-orphant allt merget expunges save-updates refresh-expiret nonet CascadeOptionsc B sS e Z d Z e j d d d g Z e Z d
Z d
Z d Z e
d Z RS( s9 Keeps track of the options sent to relationship().cascadeR R s
delete-orphant save_updateR t refresh_expireR R t
delete_orphanc C sk t | t j s | d k r+ | j | St | } | j | j r t j d d j
g t | j | j D] } t | ^ qq n d | k r² | j
| j n d | k rË | j n | j d t j t | } d | k | _ d | k | _ d | k | _ d | k | _ d | k | _ d
| k | _ | j rg| j rgt j d n | S( Ns Invalid cascade option(s): %ss , R R s save-updateR s refresh-expireR R s
delete-orphans5 The 'delete-orphan' cascade option requires 'delete'.( t
isinstanceR t string_typest Nonet from_stringt sett
differencet _allowed_cascadest sa_exct
ArgumentErrort joint sortedt reprt updatet _add_w_all_cascadest cleart discardt frozensett __new__R R R R R R R t warn( t clst
value_listt valuest xt self( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR1 % s.
8
c C s* d d j g t | D] } | ^ q S( Ns CascadeOptions(%r)t ,( R) R* ( R7 R6 ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt __repr__B s c C s; g t j d | p d D] } | r | ^ q } | | S( Ns \s*,\s*t ( t ret split( R3 t argt cR5 ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR# G s ( s save_updates deletes refresh_expires merges expunges
delete_orphan( t __name__t
__module__t __doc__t all_cascadesR% R- R& t __slots__R1 R9 t classmethodR# ( ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR s c s s f d n | ri f d } f d } f d } n0 f d } f d } t j | d | d t d t t j | d
| d t d t | rÿ t j | d | d t d t n d S(
sN Runs a validation method on an attribute value to be set or
appended.
c s | j j } | j | k S( N( t managert impl( t statet initiatorRF ( t key( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt detect_is_backrefX s c s7 s | | r/ | j | t S| Sd S( N( t objt False( RG t valueRH ( RJ t include_backrefsRI t validator( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt append] s c s7 s | | r/ | j | t S| Sd S( N( RK RL ( RG RM t oldvalueRH ( RJ RN RI RO ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt set_c s c s6 s | | r2 | j | t n d S( N( RK t True( RG RM RH ( RJ RN RI RO ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt removei s c s4 s | | r, | j | S| Sd S( N( RK ( RG RM RH ( RJ RN RI RO ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyRP n s c s4 s | | r, | j | S| Sd S( N( RK ( RG RM RQ RH ( RJ RN RI RO ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyRR t s RP t rawt retvalR$ RT N( R t listenRS ( t descRI RO t include_removesRN RP RR RT ( ( RJ RN RI RO sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt _validator_eventsQ s t p_unionc
s¤ t j } i i x | D] } | | } t | t j rZ | j } | | | <n i } x> | j D]3 } | j | j | | | j <| j | j <qj W| | <q W f d } g }
xÁ | j
D]³ \ } } | d k rO|
j t j
g | D] } | | | ^ qt j t j | j | g d | g q× |
j t j
g | D] } | | | ^ qbd | g q× Wt j |
j | S( s) Create a ``UNION`` statement used by a polymorphic mapper.
See :ref:`concrete_inheritance` for an example of how
this is used.
:param table_map: mapping of polymorphic identities to
:class:`.Table` objects.
:param typecolname: string name of a "discriminator" column, which will be
derived from the query, producing the polymorphic identity for
each row. If ``None``, no polymorphic discriminator is generated.
:param aliasname: name of the :func:`~sqlalchemy.sql.expression.alias()`
construct generated.
:param cast_nulls: if True, non-existent columns, which are represented
as labeled NULLs, will be passed into CAST. This is a legacy behavior
that is problematic on some backends such as Oracle - in which case it
can be set to False.
c st y | | SWn] t k
ro rI t j t j | j | St j t j | j | Sn Xd S( N( t KeyErrorR t castt nullt labelt type_coerce( t namet table( t
cast_nullst colnamemapst types( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt col¨ s
#t from_objN( R t
OrderedSetR R t Selectt aliasR> t addRI t typet itemsR" RP t selectt literal_columnt sql_utilt _quote_ddl_exprR_ t union_all(
t table_mapt typecolnamet aliasnameRc t colnamesRI Rb t mR> Rf t resultRl Ra ( ( Rc Rd Re sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt polymorphic_union s6
%
.c O si | rt | d k r[ | d } y | j d } Wq¶ t k
rW | j d } q¶ Xn[ t | d k r| | \ } } n: t | d k r | \ } } n t j d t | | rÛ t j d d j | n t | } d t k r | j t j
| S| j | S| j d
} | rPt j d d j | j n t
| } | j | S( s Generate "identity key" tuples, as are used as keys in the
:attr:`.Session.identity_map` dictionary.
This function has several call styles:
* ``identity_key(class, ident)``
This form receives a mapped class and a primary key scalar or
tuple as an argument.
E.g.::
>>> identity_key(MyClass, (1, 2))
(<class '__main__.MyClass'>, (1, 2))
:param class: mapped class (must be a positional argument)
:param ident: primary key, may be a scalar or tuple argument.
* ``identity_key(instance=instance)``
This form will produce the identity key for a given instance. The
instance need not be persistent, only that its primary key attributes
are populated (else the key will contain ``None`` for those missing
values).
E.g.::
>>> instance = MyClass(1, 2)
>>> identity_key(instance=instance)
(<class '__main__.MyClass'>, (1, 2))
In this form, the given instance is ultimately run though
:meth:`.Mapper.identity_key_from_instance`, which will have the
effect of performing a database check for the corresponding row
if the object is expired.
:param instance: object instance (must be given as a keyword arg)
* ``identity_key(class, row=row)``
This form is similar to the class/tuple form, except is passed a
database result row as a :class:`.RowProxy` object.
E.g.::
>>> row = engine.execute("select * from table where a=1 and b=2").first()
>>> identity_key(MyClass, row=row)
(<class '__main__.MyClass'>, (1, 2))
:param class: mapped class (must be a positional argument)
:param row: :class:`.RowProxy` row returned by a :class:`.ResultProxy`
(must be given as a keyword arg)
i i t rowt identi i s1 expected up to three positional arguments, got %ss unknown keyword arguments: %ss , t instance( t lent popR\ R' R( R) R t localst identity_key_from_primary_keyR t to_listt identity_key_from_rowt keysR t identity_key_from_instance( t argst kwargst class_Rz R{ t mapperR| ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt identity_keyÀ s6 9
t
ORMAdapterc B s/ e Z d Z d e d e e d Z d Z RS( sa ColumnAdapter subclass which excludes adaptation of entities from
non-matching mappers.
c
C s t j | } | j | _ | j } | j } | r? | | _ n d | _ t j j | | | | d | d | d | d | j
d S( Nt adapt_requiredt allow_label_resolvet anonymize_labelst
include_fn( R t inspectR t
selectablet is_aliased_classt
aliased_classR" Rp t
ColumnAdaptert __init__t _include_fn(
R7 t entityt equivalentsR t chain_toR R t infoR R ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR s c C s, | j j d d } | p+ | j | j S( Nt parentmapper( t _annotationst getR" t isaR ( R7 t elemR ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR 2 s N( R? R@ RA R" RL RS R R ( ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR s
t AliasedClassc B sA e Z d Z d d e e d d d e d Z d Z d Z RS( s Represents an "aliased" form of a mapped class for usage with Query.
The ORM equivalent of a :func:`sqlalchemy.sql.expression.alias`
construct, this object mimics the mapped class using a
__getattr__ scheme and maintains a reference to a
real :class:`~sqlalchemy.sql.expression.Alias` object.
Usage is via the :func:`.orm.aliased` function, or alternatively
via the :func:`.orm.with_polymorphic` function.
Usage example::
# find all pairs of users with the same name
user_alias = aliased(User)
session.query(User, user_alias).\
join((user_alias, User.id > user_alias.id)).\
filter(User.name==user_alias.name)
The resulting object is an instance of :class:`.AliasedClass`.
This object implements an attribute scheme which produces the
same attribute and method interface as the original mapped
class, allowing :class:`.AliasedClass` to be compatible
with any attribute technique which works on the original class,
including hybrid attributes (see :ref:`hybrids_toplevel`).
The :class:`.AliasedClass` can be inspected for its underlying
:class:`.Mapper`, aliased selectable, and other information
using :func:`.inspect`::
from sqlalchemy import inspect
my_alias = aliased(MyClass)
insp = inspect(my_alias)
The resulting inspection object is an instance of :class:`.AliasedInsp`.
See :func:`.aliased` and :func:`.with_polymorphic` for construction
argument descriptions.
c
C s t | }
| d k r6 |
j j d | d | } n t | |
| | | rQ | n |
j | d k ri | n |
j | | | | _ d |
j j | _ d S( NRa t flats AliasedClass_%s(
R R" t _with_polymorphic_selectableRj t AliasedInspt with_polymorphic_mapperst polymorphic_ont
_aliased_inspR R? ( R7 R3 Rj Ra R t adapt_on_namesR£ t with_polymorphic_discriminatort
base_aliast use_mapper_pathR ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR ` s" c C sV y | j d } Wn t k
r- t nR XxN | j j D]4 } y t j | | } Wn t k
rm q; q; XPq; Wt | t | t r± | j | } t
| | | | St | d r
t | j | d } | r| j d k rt j j | j | | Sd SnH t | d rN| j d | } t | t rG| j | S| Sn | Sd S( NR¥ t func_codet __get__( t __dict__R\ t AttributeErrort _targett __mro__t objectt __getattribute__R R t adapt_to_entityt setattrt hasattrt getattrR" t __self__R Re t
MethodTypet __func__R« ( R7 RI R¥ t baset attrt rett is_method( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt __getattr__ s4
c C s d t | | j j j f S( Ns <AliasedClass at 0x%x; %s>( t idR¥ R® R? ( R7 ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR9 £ s N( ( R? R@ RA R" RL R R½ R9 ( ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR 7 s ' #R¢ c B sk e Z d Z d Z e Z e d Z e j d Z
d Z d Z d Z
d Z d Z RS( s» Provide an inspection interface for an
:class:`.AliasedClass` object.
The :class:`.AliasedInsp` object is returned
given an :class:`.AliasedClass` using the
:func:`.inspect` function::
from sqlalchemy import inspect
from sqlalchemy.orm import aliased
my_alias = aliased(MyMappedClass)
insp = inspect(my_alias)
Attributes on :class:`.AliasedInsp`
include:
* ``entity`` - the :class:`.AliasedClass` represented.
* ``mapper`` - the :class:`.Mapper` mapping the underlying class.
* ``selectable`` - the :class:`.Alias` construct which ultimately
represents an aliased :class:`.Table` or :class:`.Select`
construct.
* ``name`` - the name of the alias. Also is used as the attribute
name when returned in a result tuple from :class:`.Query`.
* ``with_polymorphic_mappers`` - collection of :class:`.Mapper` objects
indicating all those mappers expressed in the select construct
for the :class:`.AliasedClass`.
* ``polymorphic_on`` - an alternate column or SQL expression which
will be used as the "discriminator" for a polymorphic load.
.. seealso::
:ref:`inspection_toplevel`
c
C sè | | _ | | _ | | _ | | _ | | _ | | _ | p? | | _ | | _ t j | d | j
d | d t | _ | | _
| j | _ xW | j D]L }
|
| k r t | j |
j j t |
j | d | d | d | q q Wd S( NR R¦ R R¨ R© ( R R R Ra R£ R¤ t _base_aliast _use_mapper_pathRp R t _equivalent_columnsRS t _adaptert _adapt_on_namesR R® R³ R? R ( R7 R R R Ra R£ R¤ R¿ RÀ R¦ t poly( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR Ì s& c C s
| j j S( sU Return the mapped class ultimately represented by this
:class:`.AliasedInsp`.( R R ( R7 ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR é s c C s$ | j r | j j St j | Sd S( N( RÀ R t _path_registryR t
per_mapper( R7 ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyRÅ ï s
c C s^ i | j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6| j d 6S(
NR R Rj Ra R¦ R£ R§ R¨ R© ( R R R Ra RÃ R£ R¤ R¿ RÀ ( R7 ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt __getstate__ö s
c C sM | j | d | d | d | d | d | d | d | d | d d S(
NR R Rj Ra R£ R§ R¨ R© R¦ ( R ( R7 RG ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt __setstate__ s c C s* | j j | j i | d 6| j d 6 S( Nt parententityR ( RÂ t traverset _annotateR ( R7 R ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt _adapt_element s c C sz | j } | | k rD | | j k r( | St | j | j j j Sn2 | j | j rZ | St sv t d | | f d S( Ns" mapper %s doesn't correspond to %s(
R£ R Rµ R R R? R¥ R RL t AssertionError( R7 R t self_poly( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt _entity_for_mapper s c C sO | j r, d d j d | j D } n d } d t | | j j | f S( Ns (%s)s , c s s | ] } | j j Vq d S( N( R R? ( t .0t mp( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pys <genexpr>* s R: s <AliasedInsp at 0x%x; %s%s>( R£ R) R¾ R R? ( R7 t with_poly( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR9 ' s ( R? R@ RA R RS R t propertyR R t memoized_propertyRÅ RÇ RÈ RÌ RÏ R9 ( ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR¢ ¨ s "
c C s | j S( N( R¥ ( t target( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt <lambda>1 s c C s | S( N( ( RÕ ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyRÖ 2 s c
C sc t | t j r= | r* t j d n | j | d | St | d | d | d | d | Sd S( s Produce an alias of the given element, usually an :class:`.AliasedClass`
instance.
E.g.::
my_alias = aliased(MyClass)
session.query(MyClass, my_alias).filter(MyClass.id > my_alias.id)
The :func:`.aliased` function is used to create an ad-hoc mapping
of a mapped class to a new selectable. By default, a selectable
is generated from the normally mapped selectable (typically a
:class:`.Table`) using the :meth:`.FromClause.alias` method.
However, :func:`.aliased` can also be used to link the class to
a new :func:`.select` statement. Also, the :func:`.with_polymorphic`
function is a variant of :func:`.aliased` that is intended to specify
a so-called "polymorphic selectable", that corresponds to the union
of several joined-inheritance subclasses at once.
For convenience, the :func:`.aliased` function also accepts plain
:class:`.FromClause` constructs, such as a :class:`.Table` or
:func:`.select` construct. In those cases, the :meth:`.FromClause.alias`
method is called on the object and the new :class:`.Alias` object
returned. The returned :class:`.Alias` is not ORM-mapped in this case.
:param element: element to be aliased. Is normally a mapped class,
but for convenience can also be a :class:`.FromClause` element.
:param alias: Optional selectable unit to map the element to. This should
normally be a :class:`.Alias` object corresponding to the :class:`.Table`
to which the class is mapped, or to a :func:`.select` construct that
is compatible with the mapping. By default, a simple anonymous
alias of the mapped table is generated.
:param name: optional string name to use for the alias, if not specified
by the ``alias`` parameter. The name, among other things, forms the
attribute name that will be accessible via tuples returned by a
:class:`.Query` object.
:param flat: Boolean, will be passed through to the
:meth:`.FromClause.alias` call so that aliases of :class:`.Join` objects
don't include an enclosing SELECT. This can lead to more efficient
queries in many circumstances. A JOIN against a nested JOIN will be
rewritten as a JOIN against an aliased SELECT subquery on backends that
don't support this syntax.
.. versionadded:: 0.9.0
.. seealso:: :meth:`.Join.alias`
:param adapt_on_names: if True, more liberal "matching" will be used when
mapping the mapped columns of the ORM entity to those of the
given selectable - a name-based match will be performed if the
given selectable doesn't otherwise have a column that corresponds
to one on the entity. The use case for this is when associating
an entity with some derived selectable such as one that uses
aggregate functions::
class UnitPrice(Base):
__tablename__ = 'unit_price'
...
unit_id = Column(Integer)
price = Column(Numeric)
aggregated_unit_price = Session.query(
func.sum(UnitPrice.price).label('price')
).group_by(UnitPrice.unit_id).subquery()
aggregated_unit_price = aliased(UnitPrice,
alias=aggregated_unit_price, adapt_on_names=True)
Above, functions on ``aggregated_unit_price`` which refer to
``.price`` will return the
``fund.sum(UnitPrice.price).label('price')`` column, as it is
matched on the name "price". Ordinarily, the "price" function
wouldn't have any "column correspondence" to the actual
``UnitPrice.price`` column as it is not a proxy of the original.
.. versionadded:: 0.7.3
s+ adapt_on_names only applies to ORM elementsR Rj Ra R¦ N( R R t
FromClauseR' R( Rj R ( t elementRj Ra R R¦ ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt aliased5 s S c
C sÛ t | } | r} | j | k s' t t j | } t g | j D] }
|
j ^ qC } | | k rk | S| j | } n | j | | d | \ } } | s§ | r¼ | j
d | } n t | | d | d | d | S( s± Produce an :class:`.AliasedClass` construct which specifies
columns for descendant mappers of the given base.
.. versionadded:: 0.8
:func:`.orm.with_polymorphic` is in addition to the existing
:class:`.Query` method :meth:`.Query.with_polymorphic`,
which has the same purpose but is not as flexible in its usage.
Using this method will ensure that each descendant mapper's
tables are included in the FROM clause, and will allow filter()
criterion to be used against those tables. The resulting
instances will also have those columns already loaded so that
no "post fetch" of those columns will be required.
See the examples at :ref:`with_polymorphic`.
:param base: Base class to be aliased.
:param classes: a single class or mapper, or list of
class/mappers, which inherit from the base class.
Alternatively, it may also be the string ``'*'``, in which case
all descending mapped classes will be added to the FROM clause.
:param aliased: when True, the selectable will be wrapped in an
alias, that is ``(SELECT * FROM <fromclauses>) AS anon_1``.
This can be important when using the with_polymorphic()
to create the target of a JOIN on a backend that does not
support parenthesized joins, such as SQLite and older
versions of MySQL.
:param flat: Boolean, will be passed through to the
:meth:`.FromClause.alias` call so that aliases of :class:`.Join`
objects don't include an enclosing SELECT. This can lead to more
efficient queries in many circumstances. A JOIN against a nested JOIN
will be rewritten as a JOIN against an aliased SELECT subquery on
backends that don't support this syntax.
Setting ``flat`` to ``True`` implies the ``aliased`` flag is
also ``True``.
.. versionadded:: 0.9.0
.. seealso:: :meth:`.Join.alias`
:param selectable: a table or select() statement that will
be used in place of the generated FROM clause. This argument is
required if any of the desired classes use concrete table
inheritance, since SQLAlchemy currently cannot generate UNIONs
among tables automatically. If used, the ``selectable`` argument
must represent the full set of tables and columns mapped by every
mapped class. Otherwise, the unaccounted mapped columns will
result in their table being appended directly to the FROM clause
which will usually lead to incorrect results.
:param polymorphic_on: a column to be used as the "discriminator"
column for the given selectable. If not given, the polymorphic_on
attribute of the base classes' mapper will be used, if any. This
is useful for mappings that don't have polymorphic loading
behavior by default.
:param innerjoin: if True, an INNER JOIN will be used. This should
only be specified if querying for one specific subtype only
t innerjoinR R£ R§ R© ( R R RÍ R t to_setR$ R£ R t uniont _with_polymorphic_argsRj R (
R¹ t classesR R R¤ RÙ RÚ RÀ t _existing_aliast primary_mapperRÑ t new_classest mappers( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt with_polymorphic s( D c C s t j | i t d 6| S( s® Deep copy the given ClauseElement, annotating each element with the
"_orm_adapt" flag.
Elements within the exclude collection will be cloned but not annotated.
t
_orm_adapt( Rp t _deep_annotateRS ( RØ t exclude( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt
_orm_annotateî s c C s t j | d d S( sÔ Remove annotations that link a column to a particular mapping.
Note this doesn't affect "remote" and "foreign" annotations
passed by the :func:`.orm.foreign` and :func:`.orm.remote`
annotators.
R5 Rä RÉ ( s
_orm_adapts parententity( Rp t _deep_deannotate( RØ ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt _orm_deannotateø s c C s
t j | S( N( Rp Rè ( RØ ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt _orm_full_deannotate s t _ORMJoinc B sY e Z d Z e j j Z d e d d d Z d Z d e d d Z
d d d Z RS( s/ Extend Join to support ORM constructs as input.c C s2 t j | } t | d | } t j | } | j }
| | _ | | _ | | _ t | t j r{ t | j
| } n t | t j r¨ | j
j } | j } n* t | t rÌ | } | j j } n d } | r¡t j | | j rö | }
n | j }
| j d |
d |
d t d t d | j \ } } } } } } | d k r| rnt j | | | } | } qt j | | | | } | } n | } | | _ n t j j | | | | | | r.t | d d r.| j j r.| j j } | d k r.| j r| j! j" | } n | j# | @| _# q.n d S( Nt _joined_from_infot source_selectablet dest_selectablet source_polymorphict dest_polymorphict of_typeR ($ R R Rµ R Rì t
_left_memot _right_memoR R R! R R t QueryableAttributet
comparatort _source_selectableRÓ R t parentR" Rp t clause_is_presentt
_create_joinsRS R R R) t _target_adapterR t JoinR t singlet _single_table_criterionR RÂ RÊ t onclause( R7 t leftt rightRþ t isouterRò Ró t left_infot
left_orm_infot
right_infot adapt_tot
on_selectablet propt
adapt_fromt pjt sjt sourcet destt secondaryt target_adaptert single_crit( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR sV c
C s | } x t | t j r' | j } q W| j | k s= t t | j | j | j d | j d | j d | j } t | | j | j d | j d | j
S( sl Splice a join into the center.
Given join(a, b) and join(b, c), return join(a, b).join(c)
R Rò Ró ( R R Rû Rÿ R RÍ Rë Rþ R Rò Ró ( R7 t othert leftmostRÿ ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt _splice_into_centerS s
c C s t | | | | S( N( Rë ( R7 R Rþ R t join_to_left( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR) m s c C s t | | | t S( N( Rë RS ( R7 R Rþ R ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt outerjoinp s N( R? R@ RA R Rû t __visit_name__R" RL R R R) R ( ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyRë
s A c C s t | | | | S( s¯ Produce an inner join between left and right clauses.
:func:`.orm.join` is an extension to the core join interface
provided by :func:`.sql.expression.join()`, where the
left and right selectables may be not only core selectable
objects such as :class:`.Table`, but also mapped classes or
:class:`.AliasedClass` instances. The "on" clause can
be a SQL expression, or an attribute or string name
referencing a configured :func:`.relationship`.
:func:`.orm.join` is not commonly needed in modern usage,
as its functionality is encapsulated within that of the
:meth:`.Query.join` method, which features a
significant amount of automation beyond :func:`.orm.join`
by itself. Explicit usage of :func:`.orm.join`
with :class:`.Query` involves usage of the
:meth:`.Query.select_from` method, as in::
from sqlalchemy.orm import join
session.query(User).\
select_from(join(User, Address, User.addresses)).\
filter(Address.email_address=='foo@bar.com')
In modern SQLAlchemy the above join can be written more
succinctly as::
session.query(User).\
join(User.addresses).\
filter(Address.email_address=='foo@bar.com')
See :meth:`.Query.join` for information on modern usage
of ORM level joins.
.. versionchanged:: 0.8.1 - the ``join_to_left`` parameter
is no longer used, and is deprecated.
( Rë ( Rÿ R Rþ R R ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR) t s &c C s t | | | t S( s Produce a left outer join between left and right clauses.
This is the "outer join" version of the :func:`.orm.join` function,
featuring the same behavior except that an OUTER JOIN is generated.
See that function's documentation for other usage details.
( Rë RS ( Rÿ R Rþ R ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR s c C sa t | t j r6 t | } t | j | j } n t | t j rT | j } n | j | S( s$ Create filtering criterion that relates this query's primary entity
to the given related instance, using established :func:`.relationship()`
configuration.
The SQL rendered is the same as that rendered when a lazy loader
would fire off from the given parent on that attribute, meaning
that the appropriate state is taken from the parent object in
Python without the need to render joins to the parent table
in the rendered statement.
.. versionchanged:: 0.6.4
This method accepts parent instances in all
persistence states, including transient, persistent, and detached.
Only the requisite primary key/foreign key attributes need to
be populated. Previous versions didn't work with transient
instances.
:param instance:
An instance which has some :func:`.relationship`.
:param property:
String property name, or class-bound attribute, which indicates
what relationship from the instance should be used to reconcile the
parent/child relationship.
(
R R R! R Rµ R RÓ R Rô t _with_parent( R| R R ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt with_parent¨ s c C s t j | } | j S( sÖ Return True if the given object has a database
identity.
This typically corresponds to the object being
in either the persistent or detached state.
.. seealso::
:func:`.was_deleted`
( R t instance_statet has_identity( R° RG ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyR Ì s c C s t j | } | j S( sj Return True if the given object was deleted
within a session flush.
.. versionadded:: 0.8.0
( R R t deleted( R° RG ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt was_deletedÜ s c C sk d d l m } m } m } m } d d l m } d d l m } | | _ | _ | _ | _ | _ d S( s¼ Use random-ordering sets within the unit of work in order
to detect unit of work sorting issues.
This is a utility function that can be used to help reproduce
inconsistent unit of work sorting issues. For example,
if two kinds of objects A and B are being inserted, and
B has a foreign key reference to A - the A must be inserted first.
However, if there is no relationship between A and B, the unit of work
won't know to perform this sorting, and an operation may or may not
fail, depending on how the ordering works out. Since Python sets
and dictionaries have non-deterministic ordering, such an issue may
occur on some runs and not on others, and in practice it tends to
have a great dependence on the state of the interpreter. This leads
to so-called "heisenbugs" where changing entirely irrelevant aspects
of the test program still cause the failure behavior to change.
By calling ``randomize_unitofwork()`` when a script first runs, the
ordering of a key series of sets within the unit of work implementation
are randomized, so that the script can be minimized down to the
fundamental mapping and operation that's failing, while still reproducing
the issue on at least some runs.
This utility is also available when running the test suite via the
``--reversetop`` flag.
.. versionadded:: 0.8.1 created a standalone version of the
``--reversetop`` feature.
iÿÿÿÿ( t
unitofworkt sessionR t
dependency( t topological( t RandomSetN(
t sqlalchemy.ormR R R R t sqlalchemy.utilR t sqlalchemy.testing.utilR R$ ( R R R R R R ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt randomize_unitofworkè s "( s deletes
delete-orphans alls merges expunges save-updates refresh-expires none(: R: R R R R R' R R Rp R t
interfacesR R R R; R¹ R
R R R
R R R R R R R R t
path_registryR R0 RB R RZ RS Ry R R R R° R R¢ t _inspectsR" RL RÙ Rã Rç Ré Rê Rû Rë R) R R R R R$ ( ( ( sH /home/tvault/.virtenv/lib/python2.7/site-packages/sqlalchemy/orm/util.pyt <module> sH ( @ 7 0? W q^ W
j) $