File Manager

Hackfut Security File Manager

Current Path: /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/orm

opt / alt / python27 / lib64 / python2.7 / site-packages / sqlalchemy / orm /

📁 ..
📄 __init__.py(7.9 KB)
📄 __init__.pyc(9.31 KB)
📄 __init__.pyo(9.31 KB)
📄 attributes.py(55.94 KB)
📄 attributes.pyc(55.59 KB)
📄 attributes.pyo(55.32 KB)
📄 base.py(14.32 KB)
📄 base.pyc(15.11 KB)
📄 base.pyo(15.11 KB)
📄 collections.py(51.18 KB)
📄 collections.pyc(62.31 KB)
📄 collections.pyo(62.1 KB)
📄 dependency.py(45.11 KB)
📄 dependency.pyc(28.68 KB)
📄 dependency.pyo(28.59 KB)
📄 deprecated_interfaces.py(17.83 KB)
📄 deprecated_interfaces.pyc(21.11 KB)
📄 deprecated_interfaces.pyo(21.11 KB)
📄 descriptor_props.py(24.95 KB)
📄 descriptor_props.pyc(28.1 KB)
📄 descriptor_props.pyo(28.1 KB)
📄 dynamic.py(12.84 KB)
📄 dynamic.pyc(14.42 KB)
📄 dynamic.pyo(14.42 KB)
📄 evaluator.py(4.7 KB)
📄 evaluator.pyc(7.19 KB)
📄 evaluator.pyo(7.19 KB)
📄 events.py(83.09 KB)
📄 events.pyc(91.58 KB)
📄 events.pyo(91.58 KB)
📄 exc.py(5.31 KB)
📄 exc.pyc(7.75 KB)
📄 exc.pyo(7.75 KB)
📄 identity.py(10.01 KB)
📄 identity.pyc(14.76 KB)
📄 identity.pyo(14.76 KB)
📄 instrumentation.py(17.1 KB)
📄 instrumentation.pyc(20.65 KB)
📄 instrumentation.pyo(20.57 KB)
📄 interfaces.py(21.56 KB)
📄 interfaces.pyc(26.11 KB)
📄 interfaces.pyo(26.11 KB)
📄 loading.py(25.29 KB)
📄 loading.pyc(15.28 KB)
📄 loading.pyo(15.28 KB)
📄 mapper.py(116.54 KB)
📄 mapper.pyc(92.81 KB)
📄 mapper.pyo(92.66 KB)
📄 path_registry.py(7.57 KB)
📄 path_registry.pyc(12.58 KB)
📄 path_registry.pyo(12.58 KB)
📄 persistence.py(52.41 KB)
📄 persistence.pyc(41.25 KB)
📄 persistence.pyo(41.25 KB)
📄 properties.py(10.21 KB)
📄 properties.pyc(11.3 KB)
📄 properties.pyo(11.3 KB)
📄 query.py(150.98 KB)
📄 query.pyc(143.06 KB)
📄 query.pyo(143.02 KB)
📄 relationships.py(115.47 KB)
📄 relationships.pyc(100.36 KB)
📄 relationships.pyo(100.33 KB)
📄 scoping.py(6.27 KB)
📄 scoping.pyc(7.5 KB)
📄 scoping.pyo(7.5 KB)
📄 session.py(117.07 KB)
📄 session.pyc(110.77 KB)
📄 session.pyo(110.6 KB)
📄 state.py(26.85 KB)
📄 state.pyc(28.61 KB)
📄 state.pyo(28.61 KB)
📄 strategies.py(60.93 KB)
📄 strategies.pyc(45.88 KB)
📄 strategies.pyo(45.54 KB)
📄 strategy_options.py(35.07 KB)
📄 strategy_options.pyc(36.87 KB)
📄 strategy_options.pyo(36.87 KB)
📄 sync.py(5.32 KB)
📄 sync.pyc(4.48 KB)
📄 sync.pyo(4.48 KB)
📄 unitofwork.py(23.43 KB)
📄 unitofwork.pyc(23.57 KB)
📄 unitofwork.pyo(23.49 KB)
📄 util.py(37.64 KB)
📄 util.pyc(38.09 KB)
📄 util.pyo(37.94 KB)

Editing: dynamic.py

# orm/dynamic.py
# Copyright (C) 2005-2017 the SQLAlchemy authors and contributors
# <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php

"""Dynamic collection API.

Dynamic collections act like Query() objects for read operations and support
basic add/delete mutation.

"""

from .. import log, util, exc
from ..sql import operators
from . import (
    attributes, object_session, util as orm_util, strategies,
    object_mapper, exc as orm_exc, properties
)
from .query import Query

@log.class_logger
@properties.RelationshipProperty.strategy_for(lazy="dynamic")
class DynaLoader(strategies.AbstractRelationshipLoader):
    def init_class_attribute(self, mapper):
        self.is_class_level = True
        if not self.uselist:
            raise exc.InvalidRequestError(
                "On relationship %s, 'dynamic' loaders cannot be used with "
                "many-to-one/one-to-one relationships and/or "
                "uselist=False." % self.parent_property)
        strategies._register_attribute(
            self.parent_property,
            mapper,
            useobject=True,
            impl_class=DynamicAttributeImpl,
            target_mapper=self.parent_property.mapper,
            order_by=self.parent_property.order_by,
            query_class=self.parent_property.query_class,
        )

class DynamicAttributeImpl(attributes.AttributeImpl):
    uses_objects = True
    accepts_scalar_loader = False
    supports_population = False
    collection = False

def __init__(self, class_, key, typecallable,
                 dispatch,
                 target_mapper, order_by, query_class=None, **kw):
        super(DynamicAttributeImpl, self).\
            __init__(class_, key, typecallable, dispatch, **kw)
        self.target_mapper = target_mapper
        self.order_by = order_by
        if not query_class:
            self.query_class = AppenderQuery
        elif AppenderMixin in query_class.mro():
            self.query_class = query_class
        else:
            self.query_class = mixin_user_query(query_class)

def get(self, state, dict_, passive=attributes.PASSIVE_OFF):
        if not passive & attributes.SQL_OK:
            return self._get_collection_history(
                state, attributes.PASSIVE_NO_INITIALIZE).added_items
        else:
            return self.query_class(self, state)

def get_collection(self, state, dict_, user_data=None,
                       passive=attributes.PASSIVE_NO_INITIALIZE):
        if not passive & attributes.SQL_OK:
            return self._get_collection_history(state,
                                                passive).added_items
        else:
            history = self._get_collection_history(state, passive)
            return history.added_plus_unchanged

@util.memoized_property
    def _append_token(self):
        return attributes.Event(self, attributes.OP_APPEND)

@util.memoized_property
    def _remove_token(self):
        return attributes.Event(self, attributes.OP_REMOVE)

def fire_append_event(self, state, dict_, value, initiator,
                          collection_history=None):
        if collection_history is None:
            collection_history = self._modified_event(state, dict_)

collection_history.add_added(value)

for fn in self.dispatch.append:
            value = fn(state, value, initiator or self._append_token)

if self.trackparent and value is not None:
            self.sethasparent(attributes.instance_state(value), state, True)

def fire_remove_event(self, state, dict_, value, initiator,
                          collection_history=None):
        if collection_history is None:
            collection_history = self._modified_event(state, dict_)

collection_history.add_removed(value)

if self.trackparent and value is not None:
            self.sethasparent(attributes.instance_state(value), state, False)

for fn in self.dispatch.remove:
            fn(state, value, initiator or self._remove_token)

def _modified_event(self, state, dict_):

if self.key not in state.committed_state:
            state.committed_state[self.key] = CollectionHistory(self, state)

state._modified_event(dict_,
                              self,
                              attributes.NEVER_SET)

# this is a hack to allow the fixtures.ComparableEntity fixture
        # to work
        dict_[self.key] = True
        return state.committed_state[self.key]

def set(self, state, dict_, value, initiator=None,
            passive=attributes.PASSIVE_OFF,
            check_old=None, pop=False, _adapt=True):
        if initiator and initiator.parent_token is self.parent_token:
            return

if pop and value is None:
            return

iterable = value
        new_values = list(iterable)
        if state.has_identity:
            old_collection = util.IdentitySet(self.get(state, dict_))

collection_history = self._modified_event(state, dict_)
        if not state.has_identity:
            old_collection = collection_history.added_items
        else:
            old_collection = old_collection.union(
                collection_history.added_items)

idset = util.IdentitySet
        constants = old_collection.intersection(new_values)
        additions = idset(new_values).difference(constants)
        removals = old_collection.difference(constants)

for member in new_values:
            if member in additions:
                self.fire_append_event(state, dict_, member, None,
                                       collection_history=collection_history)

for member in removals:
            self.fire_remove_event(state, dict_, member, None,
                                   collection_history=collection_history)

def delete(self, *args, **kwargs):
        raise NotImplementedError()

def set_committed_value(self, state, dict_, value):
        raise NotImplementedError("Dynamic attributes don't support "
                                  "collection population.")

def get_history(self, state, dict_, passive=attributes.PASSIVE_OFF):
        c = self._get_collection_history(state, passive)
        return c.as_history()

def get_all_pending(self, state, dict_,
                        passive=attributes.PASSIVE_NO_INITIALIZE):
        c = self._get_collection_history(
            state, passive)
        return [
            (attributes.instance_state(x), x)
            for x in
            c.all_items
        ]

def _get_collection_history(self, state, passive=attributes.PASSIVE_OFF):
        if self.key in state.committed_state:
            c = state.committed_state[self.key]
        else:
            c = CollectionHistory(self, state)

if state.has_identity and (passive & attributes.INIT_OK):
            return CollectionHistory(self, state, apply_to=c)
        else:
            return c

def append(self, state, dict_, value, initiator,
               passive=attributes.PASSIVE_OFF):
        if initiator is not self:
            self.fire_append_event(state, dict_, value, initiator)

def remove(self, state, dict_, value, initiator,
               passive=attributes.PASSIVE_OFF):
        if initiator is not self:
            self.fire_remove_event(state, dict_, value, initiator)

def pop(self, state, dict_, value, initiator,
            passive=attributes.PASSIVE_OFF):
        self.remove(state, dict_, value, initiator, passive=passive)

class AppenderMixin(object):
    query_class = None

def __init__(self, attr, state):
        super(AppenderMixin, self).__init__(attr.target_mapper, None)
        self.instance = instance = state.obj()
        self.attr = attr

mapper = object_mapper(instance)
        prop = mapper._props[self.attr.key]
        self._criterion = prop._with_parent(
            instance,
            alias_secondary=False)

if self.attr.order_by:
            self._order_by = self.attr.order_by

def session(self):
        sess = object_session(self.instance)
        if sess is not None and self.autoflush and sess.autoflush \
                and self.instance in sess:
            sess.flush()
        if not orm_util.has_identity(self.instance):
            return None
        else:
            return sess
    session = property(session, lambda s, x: None)

def __iter__(self):
        sess = self.session
        if sess is None:
            return iter(self.attr._get_collection_history(
                attributes.instance_state(self.instance),
                attributes.PASSIVE_NO_INITIALIZE).added_items)
        else:
            return iter(self._clone(sess))

def __getitem__(self, index):
        sess = self.session
        if sess is None:
            return self.attr._get_collection_history(
                attributes.instance_state(self.instance),
                attributes.PASSIVE_NO_INITIALIZE).indexed(index)
        else:
            return self._clone(sess).__getitem__(index)

def count(self):
        sess = self.session
        if sess is None:
            return len(self.attr._get_collection_history(
                attributes.instance_state(self.instance),
                attributes.PASSIVE_NO_INITIALIZE).added_items)
        else:
            return self._clone(sess).count()

def _clone(self, sess=None):
        # note we're returning an entirely new Query class instance
        # here without any assignment capabilities; the class of this
        # query is determined by the session.
        instance = self.instance
        if sess is None:
            sess = object_session(instance)
            if sess is None:
                raise orm_exc.DetachedInstanceError(
                    "Parent instance %s is not bound to a Session, and no "
                    "contextual session is established; lazy load operation "
                    "of attribute '%s' cannot proceed" % (
                        orm_util.instance_str(instance), self.attr.key))

if self.query_class:
            query = self.query_class(self.attr.target_mapper, session=sess)
        else:
            query = sess.query(self.attr.target_mapper)

query._criterion = self._criterion
        query._order_by = self._order_by

return query

def extend(self, iterator):
        for item in iterator:
            self.attr.append(
                attributes.instance_state(self.instance),
                attributes.instance_dict(self.instance), item, None)

def append(self, item):
        self.attr.append(
            attributes.instance_state(self.instance),
            attributes.instance_dict(self.instance), item, None)

def remove(self, item):
        self.attr.remove(
            attributes.instance_state(self.instance),
            attributes.instance_dict(self.instance), item, None)

class AppenderQuery(AppenderMixin, Query):
    """A dynamic query that supports basic collection storage operations."""

def mixin_user_query(cls):
    """Return a new class with AppenderQuery functionality layered over."""
    name = 'Appender' + cls.__name__
    return type(name, (AppenderMixin, cls), {'query_class': cls})

class CollectionHistory(object):
    """Overrides AttributeHistory to receive append/remove events directly."""

def __init__(self, attr, state, apply_to=None):
        if apply_to:
            coll = AppenderQuery(attr, state).autoflush(False)
            self.unchanged_items = util.OrderedIdentitySet(coll)
            self.added_items = apply_to.added_items
            self.deleted_items = apply_to.deleted_items
            self._reconcile_collection = True
        else:
            self.deleted_items = util.OrderedIdentitySet()
            self.added_items = util.OrderedIdentitySet()
            self.unchanged_items = util.OrderedIdentitySet()
            self._reconcile_collection = False

@property
    def added_plus_unchanged(self):
        return list(self.added_items.union(self.unchanged_items))

@property
    def all_items(self):
        return list(self.added_items.union(
            self.unchanged_items).union(self.deleted_items))

def as_history(self):
        if self._reconcile_collection:
            added = self.added_items.difference(self.unchanged_items)
            deleted = self.deleted_items.intersection(self.unchanged_items)
            unchanged = self.unchanged_items.difference(deleted)
        else:
            added, unchanged, deleted = self.added_items,\
                self.unchanged_items,\
                self.deleted_items
        return attributes.History(
            list(added),
            list(unchanged),
            list(deleted),
        )

def indexed(self, index):
        return list(self.added_items)[index]

def add_added(self, value):
        self.added_items.add(value)

def add_removed(self, value):
        if value in self.added_items:
            self.added_items.remove(value)
        else:
            self.deleted_items.add(value)

Hackfut Security File Manager

Editing: dynamic.py

Upload File

Create Folder