def test_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(
User,
users,
properties={
"addresses": relationship(
Address,
collection_class=column_mapped_collection(
addresses.c.email_address
),
)
},
)
mapper(Address, addresses)
u1 = User()
u1.addresses = {
"email1": Address(email_address="email1"),
"email2": Address(email_address="email2"),
}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses["email1"], Address(email_address="email1"))
def test_09_pickle(self):
users = self.tables.users
mapper(User, users)
sess = fixture_session()
sess.add(User(id=1, name="ed"))
sess.commit()
sess.close()
inst = User(id=1, name="ed")
del inst._sa_instance_state
state = sa_state.InstanceState.__new__(sa_state.InstanceState)
state_09 = {
"class_": User,
"modified": False,
"committed_state": {},
"instance": inst,
"callables": {"name": state, "id": state},
"key": (User, (1,)),
"expired": True,
}
manager = instrumentation._SerializeManager.__new__(
instrumentation._SerializeManager
)
manager.class_ = User
state_09["manager"] = manager
state.__setstate__(state_09)
eq_(state.expired_attributes, {"name", "id"})
sess = fixture_session()
sess.add(inst)
eq_(inst.name, "ed")
# test identity_token expansion
eq_(sa.inspect(inst).key, (User, (1,), None))
def test_composite_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(
User,
users,
properties={
"addresses": relationship(
Address,
collection_class=column_mapped_collection(
[addresses.c.id, addresses.c.email_address]
),
)
},
)
mapper(Address, addresses)
u1 = User()
u1.addresses = {
(1, "email1"): Address(id=1, email_address="email1"),
(2, "email2"): Address(id=2, email_address="email2"),
}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(
repickled.addresses[(1, "email1")],
Address(id=1, email_address="email1"),
)
def user_loader(email):
if email not in users:
return
user = User()
user.id = email
print(user)
return user
def test_instance_deferred_cols(self):
users, addresses = (self.tables.users, self.tables.addresses)
self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
self.mapper_registry.map_imperatively(Address, addresses)
with fixture_session(expire_on_commit=False) as sess:
u1 = User(name="ed")
u1.addresses.append(Address(email_address="*****@*****.**"))
sess.add(u1)
sess.commit()
with fixture_session(expire_on_commit=False) as sess:
u1 = sess.get(
User,
u1.id,
options=[
sa.orm.defer(User.name),
sa.orm.defaultload(User.addresses).defer(
Address.email_address),
],
)
assert "name" not in u1.__dict__
assert "addresses" not in u1.__dict__
u2 = pickle.loads(pickle.dumps(u1))
with fixture_session() as sess2:
sess2.add(u2)
eq_(u2.name, "ed")
assert "addresses" not in u2.__dict__
ad = u2.addresses[0]
assert "email_address" not in ad.__dict__
eq_(ad.email_address, "*****@*****.**")
eq_(
u2,
User(name="ed",
addresses=[Address(email_address="*****@*****.**")]),
)
u2 = pickle.loads(pickle.dumps(u1))
with fixture_session() as sess2:
u2 = sess2.merge(u2, load=False)
eq_(u2.name, "ed")
assert "addresses" not in u2.__dict__
ad = u2.addresses[0]
# mapper options now transmit over merge(),
# new as of 0.6, so email_address is deferred.
assert "email_address" not in ad.__dict__
eq_(ad.email_address, "*****@*****.**")
eq_(
u2,
User(name="ed",
addresses=[Address(email_address="*****@*****.**")]),
)
def test_09_pickle(self):
users = self.tables.users
mapper(User, users)
sess = Session()
sess.add(User(id=1, name='ed'))
sess.commit()
sess.close()
inst = User(id=1, name='ed')
del inst._sa_instance_state
state = sa_state.InstanceState.__new__(sa_state.InstanceState)
state_09 = {
'class_': User,
'modified': False,
'committed_state': {},
'instance': inst,
'callables': {
'name': state,
'id': state
},
'key': (User, (1, )),
'expired': True
}
manager = instrumentation._SerializeManager.__new__(
instrumentation._SerializeManager)
manager.class_ = User
state_09['manager'] = manager
state.__setstate__(state_09)
sess = Session()
sess.add(inst)
eq_(inst.name, 'ed')
def test_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(
User,
users,
properties={
"addresses": relationship(
Address,
collection_class=column_mapped_collection(
addresses.c.email_address
),
)
},
)
mapper(Address, addresses)
u1 = User()
u1.addresses = {
"email1": Address(email_address="email1"),
"email2": Address(email_address="email2"),
}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses["email1"], Address(email_address="email1"))
def test_composite_column_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(
User,
users,
properties={
"addresses": relationship(
Address,
collection_class=column_mapped_collection(
[addresses.c.id, addresses.c.email_address]
),
)
},
)
mapper(Address, addresses)
u1 = User()
u1.addresses = {
(1, "email1"): Address(id=1, email_address="email1"),
(2, "email2"): Address(id=2, email_address="email2"),
}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(
repickled.addresses[(1, "email1")],
Address(id=1, email_address="email1"),
)
def test_class_deferred_cols(self):
addresses, users = (self.tables.addresses,
self.tables.users)
mapper(User, users, properties={
'name': sa.orm.deferred(users.c.name),
'addresses': relationship(Address, backref="user")
})
mapper(Address, addresses, properties={
'email_address': sa.orm.deferred(addresses.c.email_address)
})
sess = create_session()
u1 = User(name='ed')
u1.addresses.append(Address(email_address='*****@*****.**'))
sess.add(u1)
sess.flush()
sess.expunge_all()
u1 = sess.query(User).get(u1.id)
assert 'name' not in u1.__dict__
assert 'addresses' not in u1.__dict__
u2 = pickle.loads(pickle.dumps(u1))
sess2 = create_session()
sess2.add(u2)
eq_(u2.name, 'ed')
eq_(u2, User(name='ed', addresses=[Address(email_address='*****@*****.**')]))
u2 = pickle.loads(pickle.dumps(u1))
sess2 = create_session()
u2 = sess2.merge(u2, load=False)
eq_(u2.name, 'ed')
eq_(u2, User(name='ed', addresses=[Address(email_address='*****@*****.**')]))
def test_instance_deferred_cols(self):
users, addresses = (self.tables.users, self.tables.addresses)
mapper(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
mapper(Address, addresses)
sess = create_session()
u1 = User(name="ed")
u1.addresses.append(Address(email_address="*****@*****.**"))
sess.add(u1)
sess.flush()
sess.expunge_all()
u1 = (
sess.query(User)
.options(
sa.orm.defer("name"), sa.orm.defer("addresses.email_address")
)
.get(u1.id)
)
assert "name" not in u1.__dict__
assert "addresses" not in u1.__dict__
u2 = pickle.loads(pickle.dumps(u1))
sess2 = create_session()
sess2.add(u2)
eq_(u2.name, "ed")
assert "addresses" not in u2.__dict__
ad = u2.addresses[0]
assert "email_address" not in ad.__dict__
eq_(ad.email_address, "*****@*****.**")
eq_(
u2,
User(name="ed", addresses=[Address(email_address="*****@*****.**")]),
)
u2 = pickle.loads(pickle.dumps(u1))
sess2 = create_session()
u2 = sess2.merge(u2, load=False)
eq_(u2.name, "ed")
assert "addresses" not in u2.__dict__
ad = u2.addresses[0]
# mapper options now transmit over merge(),
# new as of 0.6, so email_address is deferred.
assert "email_address" not in ad.__dict__
eq_(ad.email_address, "*****@*****.**")
eq_(
u2,
User(name="ed", addresses=[Address(email_address="*****@*****.**")]),
)
def request_loader(request):
email = request.form.get('email')
if email not in users:
return
user = User()
user.id = email
user.is_authenticated = request.form['password'] == users[email][
'password']
return user
def test_class_deferred_cols(self):
addresses, users = (self.tables.addresses, self.tables.users)
mapper(
User,
users,
properties={
"name": sa.orm.deferred(users.c.name),
"addresses": relationship(Address, backref="user"),
},
)
mapper(
Address,
addresses,
properties={
"email_address": sa.orm.deferred(addresses.c.email_address)
},
)
with fixture_session(expire_on_commit=False) as sess:
u1 = User(name="ed")
u1.addresses.append(Address(email_address="*****@*****.**"))
sess.add(u1)
sess.commit()
with fixture_session() as sess:
u1 = sess.query(User).get(u1.id)
assert "name" not in u1.__dict__
assert "addresses" not in u1.__dict__
u2 = pickle.loads(pickle.dumps(u1))
with fixture_session() as sess2:
sess2.add(u2)
eq_(u2.name, "ed")
eq_(
u2,
User(
name="ed", addresses=[Address(email_address="*****@*****.**")]
),
)
u2 = pickle.loads(pickle.dumps(u1))
with fixture_session() as sess2:
u2 = sess2.merge(u2, load=False)
eq_(u2.name, "ed")
eq_(
u2,
User(
name="ed", addresses=[Address(email_address="*****@*****.**")]
),
)
def test_instance_lazy_relation_loaders(self):
users, addresses = (self.tables.users,
self.tables.addresses)
mapper(User, users, properties={
'addresses': relationship(Address, lazy='noload')
})
mapper(Address, addresses)
sess = Session()
u1 = User(name='ed', addresses=[
Address(
email_address='*****@*****.**',
)
])
sess.add(u1)
sess.commit()
sess.close()
u1 = sess.query(User).options(
lazyload(User.addresses)
).first()
u2 = pickle.loads(pickle.dumps(u1))
sess = Session()
sess.add(u2)
assert u2.addresses
def test_11_pickle(self):
users = self.tables.users
mapper(User, users)
sess = Session()
u1 = User(id=1, name='ed')
sess.add(u1)
sess.commit()
sess.close()
manager = instrumentation._SerializeManager.__new__(
instrumentation._SerializeManager)
manager.class_ = User
state_11 = {
'class_': User,
'modified': False,
'committed_state': {},
'instance': u1,
'manager': manager,
'key': (User, (1, )),
'expired_attributes': set(),
'expired': True
}
state = sa_state.InstanceState.__new__(sa_state.InstanceState)
state.__setstate__(state_11)
eq_(state.identity_token, None)
eq_(state.identity_key, (User, (1, ), None))
def test_options_with_descriptors(self):
users, addresses, dingalings = (self.tables.users,
self.tables.addresses,
self.tables.dingalings)
mapper(User,
users,
properties={'addresses': relationship(Address, backref="user")})
mapper(Address,
addresses,
properties={'dingaling': relationship(Dingaling)})
mapper(Dingaling, dingalings)
sess = create_session()
u1 = User(name='ed')
u1.addresses.append(Address(email_address='*****@*****.**'))
sess.add(u1)
sess.flush()
sess.expunge_all()
for opt in [
sa.orm.joinedload(User.addresses),
sa.orm.joinedload("addresses"),
sa.orm.defer("name"),
sa.orm.defer(User.name),
sa.orm.joinedload("addresses", Address.dingaling),
]:
opt2 = pickle.loads(pickle.dumps(opt))
eq_(opt.path, opt2.path)
u1 = sess.query(User).options(opt).first()
u2 = pickle.loads(pickle.dumps(u1))
def _option_test_fixture(self):
users, addresses, dingalings = (
self.tables.users,
self.tables.addresses,
self.tables.dingalings,
)
mapper(
User,
users,
properties={"addresses": relationship(Address, backref="user")},
)
mapper(
Address,
addresses,
properties={"dingaling": relationship(Dingaling)},
)
mapper(Dingaling, dingalings)
sess = fixture_session()
u1 = User(name="ed")
u1.addresses.append(Address(email_address="*****@*****.**"))
sess.add(u1)
sess.flush()
sess.expunge_all()
return sess, User, Address, Dingaling
def test_11_pickle(self):
users = self.tables.users
mapper(User, users)
sess = fixture_session()
u1 = User(id=1, name="ed")
sess.add(u1)
sess.commit()
sess.close()
manager = instrumentation._SerializeManager.__new__(
instrumentation._SerializeManager
)
manager.class_ = User
state_11 = {
"class_": User,
"modified": False,
"committed_state": {},
"instance": u1,
"manager": manager,
"key": (User, (1,)),
"expired_attributes": set(),
"expired": True,
}
state = sa_state.InstanceState.__new__(sa_state.InstanceState)
state.__setstate__(state_11)
eq_(state.identity_token, None)
eq_(state.identity_key, (User, (1,), None))
def test_lazyload_extra_criteria_not_supported(self):
users, addresses = (self.tables.users, self.tables.addresses)
mapper(
User,
users,
properties={"addresses": relationship(Address)},
)
mapper(Address, addresses)
sess = fixture_session()
u1 = User(
name="ed",
addresses=[
Address(email_address="*****@*****.**"),
Address(email_address="*****@*****.**"),
],
)
sess.add(u1)
sess.commit()
sess.close()
u1 = (sess.query(User).options(
lazyload(User.addresses.and_(
Address.email_address == "*****@*****.**"))).first())
with testing.expect_warnings(
r"Can't reliably serialize a lazyload\(\) option"):
u2 = pickle.loads(pickle.dumps(u1))
eq_(len(u1.addresses), 1)
sess = fixture_session()
sess.add(u2)
eq_(len(u2.addresses), 2)
def setUp(self):
self.token = init_token({'type': 'webauthn', 'pin': '1234'})
self.init_params = {
WEBAUTHNACTION.RELYING_PARTY_ID:
RP_ID,
WEBAUTHNACTION.RELYING_PARTY_NAME:
RP_NAME,
WEBAUTHNACTION.TIMEOUT:
TIMEOUT,
WEBAUTHNACTION.AUTHENTICATOR_ATTESTATION_FORM:
DEFAULT_AUTHENTICATOR_ATTESTATION_FORM,
WEBAUTHNACTION.USER_VERIFICATION_REQUIREMENT:
DEFAULT_USER_VERIFICATION_REQUIREMENT,
WEBAUTHNACTION.PUBLIC_KEY_CREDENTIAL_ALGORITHM_PREFERENCE:
PUBLIC_KEY_CREDENTIAL_ALGORITHM_PREFERENCE
}
self.user = User(login=USER_NAME)
self.challenge_options = {
"user": self.user,
WEBAUTHNACTION.ALLOWED_TRANSPORTS: ALLOWED_TRANSPORTS,
WEBAUTHNACTION.USER_VERIFICATION_REQUIREMENT:
DEFAULT_USER_VERIFICATION_REQUIREMENT,
WEBAUTHNACTION.TIMEOUT: TIMEOUT
}
def test_instance_deferred_cols(self):
users, addresses = (self.tables.users, self.tables.addresses)
mapper(User,
users,
properties={'addresses': relationship(Address, backref="user")})
mapper(Address, addresses)
sess = create_session()
u1 = User(name='ed')
u1.addresses.append(Address(email_address='*****@*****.**'))
sess.add(u1)
sess.flush()
sess.expunge_all()
u1 = sess.query(User).\
options(sa.orm.defer('name'),
sa.orm.defer('addresses.email_address')).\
get(u1.id)
assert 'name' not in u1.__dict__
assert 'addresses' not in u1.__dict__
u2 = pickle.loads(pickle.dumps(u1))
sess2 = create_session()
sess2.add(u2)
eq_(u2.name, 'ed')
assert 'addresses' not in u2.__dict__
ad = u2.addresses[0]
assert 'email_address' not in ad.__dict__
eq_(ad.email_address, '*****@*****.**')
eq_(u2, User(name='ed',
addresses=[Address(email_address='*****@*****.**')]))
u2 = pickle.loads(pickle.dumps(u1))
sess2 = create_session()
u2 = sess2.merge(u2, load=False)
eq_(u2.name, 'ed')
assert 'addresses' not in u2.__dict__
ad = u2.addresses[0]
# mapper options now transmit over merge(),
# new as of 0.6, so email_address is deferred.
assert 'email_address' not in ad.__dict__
eq_(ad.email_address, '*****@*****.**')
eq_(u2, User(name='ed',
addresses=[Address(email_address='*****@*****.**')]))
def test_attribute_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(User, users, properties={
'addresses': relationship(
Address,
collection_class=attribute_mapped_collection('email_address')
)
})
mapper(Address, addresses)
u1 = User()
u1.addresses = {"email1": Address(email_address="email1")}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses['email1'],
Address(email_address="email1"))
def test_attribute_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
mapper(User,
users,
properties={
'addresses':
relationship(Address,
collection_class=attribute_mapped_collection(
'email_address'))
})
mapper(Address, addresses)
u1 = User()
u1.addresses = {"email1": Address(email_address="email1")}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses['email1'], Address(email_address="email1"))
def test_loader_criteria(self, pickle_it, use_mixin):
"""test #8109"""
users, addresses = (self.tables.users, self.tables.addresses)
AddressCls = AddressWMixin if use_mixin else Address
self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(AddressCls)},
)
self.mapper_registry.map_imperatively(AddressCls, addresses)
with fixture_session(expire_on_commit=False) as sess:
u1 = User(name="ed")
u1.addresses = [
AddressCls(email_address="*****@*****.**"),
AddressCls(email_address="*****@*****.**"),
]
sess.add(u1)
sess.commit()
with fixture_session(expire_on_commit=False) as sess:
# note that non-lambda is not picklable right now as
# SQL expressions usually can't be pickled.
opt = with_loader_criteria(
Mixin if use_mixin else Address,
no_ed_foo,
include_aliases=True,
)
u1 = sess.query(User).options(opt).first()
if pickle_it:
u1 = pickle.loads(pickle.dumps(u1))
sess.close()
sess.add(u1)
eq_([ad.email_address for ad in u1.addresses], ["*****@*****.**"])
def test_attribute_mapped_collection(self):
users, addresses = self.tables.users, self.tables.addresses
self.mapper_registry.map_imperatively(
User,
users,
properties={
"addresses":
relationship(
Address,
collection_class=attribute_mapped_collection(
"email_address"),
)
},
)
self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses = {"email1": Address(email_address="email1")}
for loads, dumps in picklers():
repickled = loads(dumps(u1))
eq_(u1.addresses, repickled.addresses)
eq_(repickled.addresses["email1"], Address(email_address="email1"))
def test_invalidated_flag_pickle(self):
users, addresses = (self.tables.users, self.tables.addresses)
mapper(User,
users,
properties={'addresses': relationship(Address, lazy='noload')})
mapper(Address, addresses)
u1 = User()
u1.addresses.append(Address())
u2 = pickle.loads(pickle.dumps(u1))
u2.addresses.append(Address())
eq_(len(u2.addresses), 2)
def test_invalidated_flag_deepcopy(self):
users, addresses = (self.tables.users, self.tables.addresses)
mapper(User,
users,
properties={'addresses': relationship(Address, lazy='noload')})
mapper(Address, addresses)
u1 = User()
u1.addresses.append(Address())
u2 = copy.deepcopy(u1)
u2.addresses.append(Address())
eq_(len(u2.addresses), 2)
def test_no_mappers(self):
users = self.tables.users
umapper = mapper(User, users)
u1 = User(name='ed')
u1_pickled = pickle.dumps(u1, -1)
clear_mappers()
assert_raises_message(
orm_exc.UnmappedInstanceError, "Cannot deserialize object of type "
"<class 'sqlalchemy.testing.pickleable.User'> - no mapper()",
pickle.loads, u1_pickled)
def test_exceptions(self):
class Foo(object):
pass
users = self.tables.users
mapper(User, users)
for sa_exc in (
orm_exc.UnmappedInstanceError(Foo()),
orm_exc.UnmappedClassError(Foo),
orm_exc.ObjectDeletedError(attributes.instance_state(User())),
):
for loads, dumps in picklers():
repickled = loads(dumps(sa_exc))
eq_(repickled.args[0], sa_exc.args[0])
def test_invalidated_flag_deepcopy(self):
users, addresses = (self.tables.users, self.tables.addresses)
self.mapper_registry.map_imperatively(
User,
users,
properties={"addresses": relationship(Address, lazy="noload")},
)
self.mapper_registry.map_imperatively(Address, addresses)
u1 = User()
u1.addresses.append(Address())
u2 = copy.deepcopy(u1)
u2.addresses.append(Address())
eq_(len(u2.addresses), 2)
def test_state_info_pickle(self):
users = self.tables.users
mapper(User, users)
u1 = User(id=1, name="ed")
sa.inspect(u1).info["some_key"] = "value"
state_dict = sa.inspect(u1).__getstate__()
state = sa_state.InstanceState.__new__(sa_state.InstanceState)
state.__setstate__(state_dict)
u2 = state.obj()
eq_(sa.inspect(u2).info["some_key"], "value")
def test_no_instrumentation(self):
users = self.tables.users
mapper(User, users)
u1 = User(name="ed")
u1_pickled = pickle.dumps(u1, -1)
clear_mappers()
mapper(User, users)
u1 = pickle.loads(u1_pickled)
# this fails unless the InstanceState
# compiles the mapper
eq_(str(u1), "User(name='ed')")
def test_state_info_pickle(self):
users = self.tables.users
mapper(User, users)
u1 = User(id=1, name='ed')
sa.inspect(u1).info['some_key'] = 'value'
state_dict = sa.inspect(u1).__getstate__()
state = sa_state.InstanceState.__new__(sa_state.InstanceState)
state.__setstate__(state_dict)
u2 = state.obj()
eq_(sa.inspect(u2).info['some_key'], 'value')
def test_rebuild_state(self):
"""not much of a 'test', but illustrate how to
remove instance-level state before pickling.
"""
users = self.tables.users
mapper(User, users)
u1 = User()
attributes.manager_of_class(User).teardown_instance(u1)
assert not u1.__dict__
u2 = pickle.loads(pickle.dumps(u1))
attributes.manager_of_class(User).setup_instance(u2)
assert attributes.instance_state(u2)
