File Manager

XYZ 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(10.71 KB)
📄 __init__.pyc(12.61 KB)
📄 attributes.py(75.88 KB)
📄 attributes.pyc(70.33 KB)
📄 base.py(14.88 KB)
📄 base.pyc(15.27 KB)
📄 clsregistry.py(12.99 KB)
📄 clsregistry.pyc(15.24 KB)
📄 collections.py(53.44 KB)
📄 collections.pyc(63.92 KB)
📄 context.py(108.65 KB)
📄 context.pyc(63.05 KB)
📄 decl_api.py(34.72 KB)
📄 decl_api.pyc(37.65 KB)
📄 decl_base.py(43.69 KB)
📄 decl_base.pyc(30.85 KB)
📄 dependency.py(45.89 KB)
📄 dependency.pyc(29.02 KB)
📄 descriptor_props.py(25.38 KB)
📄 descriptor_props.pyc(28.08 KB)
📄 dynamic.py(15.64 KB)
📄 dynamic.pyc(16.76 KB)
📄 evaluator.py(7.76 KB)
📄 evaluator.pyc(10.77 KB)
📄 events.py(109.65 KB)
📄 events.pyc(117.72 KB)
📄 exc.py(6.38 KB)
📄 exc.pyc(8.27 KB)
📄 identity.py(7.06 KB)
📄 identity.pyc(10.35 KB)
📄 instrumentation.py(19.91 KB)
📄 instrumentation.pyc(22.7 KB)
📄 interfaces.py(31.59 KB)
📄 interfaces.pyc(37.42 KB)
📄 loading.py(48.16 KB)
📄 loading.pyc(29.21 KB)
📄 mapper.py(140.96 KB)
📄 mapper.pyc(108.91 KB)
📄 path_registry.py(16.01 KB)
📄 path_registry.pyc(18.51 KB)
📄 persistence.py(82.28 KB)
📄 persistence.pyc(49.3 KB)
📄 properties.py(14.44 KB)
📄 properties.pyc(15.03 KB)
📄 query.py(123 KB)
📄 query.pyc(121.3 KB)
📄 relationships.py(140.62 KB)
📄 relationships.pyc(116.6 KB)
📄 scoping.py(7.09 KB)
📄 scoping.pyc(7.46 KB)
📄 session.py(158.79 KB)
📄 session.pyc(144.25 KB)
📄 state.py(32.74 KB)
📄 state.pyc(32.94 KB)
📄 strategies.py(105.8 KB)
📄 strategies.pyc(67.54 KB)
📄 strategy_options.py(66.69 KB)
📄 strategy_options.pyc(59.79 KB)
📄 sync.py(5.69 KB)
📄 sync.pyc(4.68 KB)
📄 unitofwork.py(26.46 KB)
📄 unitofwork.pyc(25.77 KB)
📄 util.py(74.47 KB)
📄 util.pyc(70.69 KB)

Editing: evaluator.py

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

import operator

from .. import inspect
from .. import util
from ..sql import and_
from ..sql import operators
from ..sql.sqltypes import Integer
from ..sql.sqltypes import Numeric

class UnevaluatableError(Exception):
    pass

class _NoObject(operators.ColumnOperators):
    def operate(self, *arg, **kw):
        return None

def reverse_operate(self, *arg, **kw):
        return None

_NO_OBJECT = _NoObject()

_straight_ops = set(
    getattr(operators, op)
    for op in (
        "lt",
        "le",
        "ne",
        "gt",
        "ge",
        "eq",
    )
)

_math_only_straight_ops = set(
    getattr(operators, op)
    for op in (
        "add",
        "mul",
        "sub",
        "div",
        "mod",
        "truediv",
    )
)

_extended_ops = {
    operators.in_op: (lambda a, b: a in b if a is not _NO_OBJECT else None),
    operators.not_in_op: (
        lambda a, b: a not in b if a is not _NO_OBJECT else None
    ),
}

_notimplemented_ops = set(
    getattr(operators, op)
    for op in (
        "like_op",
        "not_like_op",
        "ilike_op",
        "not_ilike_op",
        "startswith_op",
        "between_op",
        "endswith_op",
    )
)

class EvaluatorCompiler(object):
    def __init__(self, target_cls=None):
        self.target_cls = target_cls

def process(self, *clauses):
        if len(clauses) > 1:
            clause = and_(*clauses)
        elif clauses:
            clause = clauses[0]

meth = getattr(self, "visit_%s" % clause.__visit_name__, None)
        if not meth:
            raise UnevaluatableError(
                "Cannot evaluate %s" % type(clause).__name__
            )
        return meth(clause)

def visit_grouping(self, clause):
        return self.process(clause.element)

def visit_null(self, clause):
        return lambda obj: None

def visit_false(self, clause):
        return lambda obj: False

def visit_true(self, clause):
        return lambda obj: True

def visit_column(self, clause):
        if "parentmapper" in clause._annotations:
            parentmapper = clause._annotations["parentmapper"]
            if self.target_cls and not issubclass(
                self.target_cls, parentmapper.class_
            ):
                raise UnevaluatableError(
                    "Can't evaluate criteria against alternate class %s"
                    % parentmapper.class_
                )
            key = parentmapper._columntoproperty[clause].key
        else:
            key = clause.key
            if (
                self.target_cls
                and key in inspect(self.target_cls).column_attrs
            ):
                util.warn(
                    "Evaluating non-mapped column expression '%s' onto "
                    "ORM instances; this is a deprecated use case.  Please "
                    "make use of the actual mapped columns in ORM-evaluated "
                    "UPDATE / DELETE expressions." % clause
                )
            else:
                raise UnevaluatableError("Cannot evaluate column: %s" % clause)

get_corresponding_attr = operator.attrgetter(key)
        return (
            lambda obj: get_corresponding_attr(obj)
            if obj is not None
            else _NO_OBJECT
        )

def visit_tuple(self, clause):
        return self.visit_clauselist(clause)

def visit_clauselist(self, clause):
        evaluators = list(map(self.process, clause.clauses))
        if clause.operator is operators.or_:

def evaluate(obj):
                has_null = False
                for sub_evaluate in evaluators:
                    value = sub_evaluate(obj)
                    if value:
                        return True
                    has_null = has_null or value is None
                if has_null:
                    return None
                return False

elif clause.operator is operators.and_:

def evaluate(obj):
                for sub_evaluate in evaluators:
                    value = sub_evaluate(obj)
                    if not value:
                        if value is None or value is _NO_OBJECT:
                            return None
                        return False
                return True

elif clause.operator is operators.comma_op:

def evaluate(obj):
                values = []
                for sub_evaluate in evaluators:
                    value = sub_evaluate(obj)
                    if value is None or value is _NO_OBJECT:
                        return None
                    values.append(value)
                return tuple(values)

else:
            raise UnevaluatableError(
                "Cannot evaluate clauselist with operator %s" % clause.operator
            )

return evaluate

def visit_binary(self, clause):
        eval_left, eval_right = list(
            map(self.process, [clause.left, clause.right])
        )
        operator = clause.operator
        if operator is operators.is_:

def evaluate(obj):
                return eval_left(obj) == eval_right(obj)

elif operator is operators.is_not:

def evaluate(obj):
                return eval_left(obj) != eval_right(obj)

elif operator is operators.concat_op:

def evaluate(obj):
                return eval_left(obj) + eval_right(obj)

elif operator in _extended_ops:

def evaluate(obj):
                left_val = eval_left(obj)
                right_val = eval_right(obj)
                if left_val is None or right_val is None:
                    return None

return _extended_ops[operator](left_val, right_val)

elif operator in _math_only_straight_ops:
            if (
                clause.left.type._type_affinity
                not in (
                    Numeric,
                    Integer,
                )
                or clause.right.type._type_affinity not in (Numeric, Integer)
            ):
                raise UnevaluatableError(
                    'Cannot evaluate math operator "%s" for '
                    "datatypes %s, %s"
                    % (operator.__name__, clause.left.type, clause.right.type)
                )

def evaluate(obj):
                left_val = eval_left(obj)
                right_val = eval_right(obj)
                if left_val is None or right_val is None:
                    return None
                return operator(eval_left(obj), eval_right(obj))

elif operator in _straight_ops:

else:
            raise UnevaluatableError(
                "Cannot evaluate %s with operator %s"
                % (type(clause).__name__, clause.operator)
            )
        return evaluate

def visit_unary(self, clause):
        eval_inner = self.process(clause.element)
        if clause.operator is operators.inv:

def evaluate(obj):
                value = eval_inner(obj)
                if value is None:
                    return None
                return not value

return evaluate
        raise UnevaluatableError(
            "Cannot evaluate %s with operator %s"
            % (type(clause).__name__, clause.operator)
        )

def visit_bindparam(self, clause):
        if clause.callable:
            val = clause.callable()
        else:
            val = clause.value
        return lambda obj: val

XYZ File Manager

Editing: evaluator.py

Upload File

Create Folder