FM / ext

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

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

Name	Size	Mode	Actions
declarative/	-	0755	rm
associationproxy.py	49463	0644	edit dl rm
associationproxy.pyc	63456	0644	edit dl rm
associationproxy.pyo	63381	0644	edit dl rm
automap.py	41710	0644	edit dl rm
automap.pyc	36915	0644	edit dl rm
automap.pyo	36915	0644	edit dl rm
baked.py	21469	0644	edit dl rm
baked.pyc	24809	0644	edit dl rm
baked.pyo	24809	0644	edit dl rm
compiler.py	16850	0644	edit dl rm
compiler.pyc	17109	0644	edit dl rm
compiler.pyo	17109	0644	edit dl rm
horizontal_shard.py	9109	0644	edit dl rm
horizontal_shard.pyc	9374	0644	edit dl rm
horizontal_shard.pyo	9335	0644	edit dl rm
hybrid.py	40233	0644	edit dl rm
hybrid.pyc	43566	0644	edit dl rm
hybrid.pyo	43566	0644	edit dl rm
indexable.py	11169	0644	edit dl rm
indexable.pyc	11456	0644	edit dl rm
indexable.pyo	11456	0644	edit dl rm
instrumentation.py	14351	0644	edit dl rm
instrumentation.pyc	17648	0644	edit dl rm
instrumentation.pyo	17648	0644	edit dl rm
mutable.py	31808	0644	edit dl rm
mutable.pyc	39139	0644	edit dl rm
mutable.pyo	39139	0644	edit dl rm
orderinglist.py	13888	0644	edit dl rm
orderinglist.pyc	16319	0644	edit dl rm
orderinglist.pyo	16319	0644	edit dl rm
serializer.py	5784	0644	edit dl rm
serializer.pyc	6048	0644	edit dl rm
serializer.pyo	6048	0644	edit dl rm
__init__.py	322	0644	edit dl rm
__init__.pyc	289	0644	edit dl rm
__init__.pyo	289	0644	edit dl rm

Edit: /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/serializer.py (5784B)

# ext/serializer.py
# Copyright (C) 2005-2019 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

"""Serializer/Deserializer objects for usage with SQLAlchemy query structures,
allowing "contextual" deserialization.

Any SQLAlchemy query structure, either based on sqlalchemy.sql.*
or sqlalchemy.orm.* can be used.  The mappers, Tables, Columns, Session
etc. which are referenced by the structure are not persisted in serialized
form, but are instead re-associated with the query structure
when it is deserialized.

Usage is nearly the same as that of the standard Python pickle module::

from sqlalchemy.ext.serializer import loads, dumps
    metadata = MetaData(bind=some_engine)
    Session = scoped_session(sessionmaker())

# ... define mappers

query = Session.query(MyClass).
        filter(MyClass.somedata=='foo').order_by(MyClass.sortkey)

# pickle the query
    serialized = dumps(query)

# unpickle.  Pass in metadata + scoped_session
    query2 = loads(serialized, metadata, Session)

print query2.all()

Similar restrictions as when using raw pickle apply; mapped classes must be
themselves be pickleable, meaning they are importable from a module-level
namespace.

The serializer module is only appropriate for query structures.  It is not
needed for:

* instances of user-defined classes.   These contain no references to engines,
  sessions or expression constructs in the typical case and can be serialized
  directly.

* Table metadata that is to be loaded entirely from the serialized structure
  (i.e. is not already declared in the application).   Regular
  pickle.loads()/dumps() can be used to fully dump any ``MetaData`` object,
  typically one which was reflected from an existing database at some previous
  point in time.  The serializer module is specifically for the opposite case,
  where the Table metadata is already present in memory.

"""

import re

from .. import Column
from .. import Table
from ..engine import Engine
from ..orm import class_mapper
from ..orm.attributes import QueryableAttribute
from ..orm.interfaces import MapperProperty
from ..orm.mapper import Mapper
from ..orm.session import Session
from ..util import b64decode
from ..util import b64encode
from ..util import byte_buffer
from ..util import pickle
from ..util import text_type

__all__ = ["Serializer", "Deserializer", "dumps", "loads"]

def Serializer(*args, **kw):
    pickler = pickle.Pickler(*args, **kw)

def persistent_id(obj):
        # print "serializing:", repr(obj)
        if isinstance(obj, QueryableAttribute):
            cls = obj.impl.class_
            key = obj.impl.key
            id_ = "attribute:" + key + ":" + b64encode(pickle.dumps(cls))
        elif isinstance(obj, Mapper) and not obj.non_primary:
            id_ = "mapper:" + b64encode(pickle.dumps(obj.class_))
        elif isinstance(obj, MapperProperty) and not obj.parent.non_primary:
            id_ = (
                "mapperprop:"
                + b64encode(pickle.dumps(obj.parent.class_))
                + ":"
                + obj.key
            )
        elif isinstance(obj, Table):
            id_ = "table:" + text_type(obj.key)
        elif isinstance(obj, Column) and isinstance(obj.table, Table):
            id_ = (
                "column:" + text_type(obj.table.key) + ":" + text_type(obj.key)
            )
        elif isinstance(obj, Session):
            id_ = "session:"
        elif isinstance(obj, Engine):
            id_ = "engine:"
        else:
            return None
        return id_

pickler.persistent_id = persistent_id
    return pickler

def Deserializer(file, metadata=None, scoped_session=None, engine=None):
    unpickler = pickle.Unpickler(file)

def get_engine():
        if engine:
            return engine
        elif scoped_session and scoped_session().bind:
            return scoped_session().bind
        elif metadata and metadata.bind:
            return metadata.bind
        else:
            return None

def persistent_load(id_):
        m = our_ids.match(text_type(id_))
        if not m:
            return None
        else:
            type_, args = m.group(1, 2)
            if type_ == "attribute":
                key, clsarg = args.split(":")
                cls = pickle.loads(b64decode(clsarg))
                return getattr(cls, key)
            elif type_ == "mapper":
                cls = pickle.loads(b64decode(args))
                return class_mapper(cls)
            elif type_ == "mapperprop":
                mapper, keyname = args.split(":")
                cls = pickle.loads(b64decode(mapper))
                return class_mapper(cls).attrs[keyname]
            elif type_ == "table":
                return metadata.tables[args]
            elif type_ == "column":
                table, colname = args.split(":")
                return metadata.tables[table].c[colname]
            elif type_ == "session":
                return scoped_session()
            elif type_ == "engine":
                return get_engine()
            else:
                raise Exception("Unknown token: %s" % type_)

unpickler.persistent_load = persistent_load
    return unpickler

def dumps(obj, protocol=pickle.HIGHEST_PROTOCOL):
    buf = byte_buffer()
    pickler = Serializer(buf, protocol)
    pickler.dump(obj)
    return buf.getvalue()

def loads(data, metadata=None, scoped_session=None, engine=None):
    buf = byte_buffer(data)
    unpickler = Deserializer(buf, metadata, scoped_session, engine)
    return unpickler.load()

cmd: