AND o.type in ('U', 'V')
""")
-# start Py2K
-# if isinstance(schema, unicode):
-# schema = schema.encode("ascii")
-# if isinstance(table_name, unicode):
-# table_name = table_name.encode("ascii")
-# end Py2K
+ if util.py2k:
+ if isinstance(schema, unicode):
+ schema = schema.encode("ascii")
+ if isinstance(table_name, unicode):
+ table_name = table_name.encode("ascii")
result = connection.execute(TABLEID_SQL,
schema_name=schema,
table_name=table_name)
AND o.type = 'U'
""")
-# start Py2K
-# if isinstance(schema, unicode):
-# schema = schema.encode("ascii")
-# end Py2K
+ if util.py2k:
+ if isinstance(schema, unicode):
+ schema = schema.encode("ascii")
+
tables = connection.execute(TABLE_SQL, schema_name=schema)
return [t["name"] for t in tables]
AND o.type = 'V'
""")
-# start Py2K
-# if isinstance(view_name, unicode):
-# view_name = view_name.encode("ascii")
-# end Py2K
+ if util.py2k:
+ if isinstance(view_name, unicode):
+ view_name = view_name.encode("ascii")
+
view = connection.execute(VIEW_DEF_SQL, view_name=view_name)
return view.scalar()
AND o.type = 'V'
""")
-# start Py2K
-# if isinstance(schema, unicode):
-# schema = schema.encode("ascii")
-# end Py2K
+ if util.py2k:
+ if isinstance(schema, unicode):
+ schema = schema.encode("ascii")
views = connection.execute(VIEW_SQL, schema_name=schema)
return [v["name"] for v in views]
_straight_ops = set(getattr(operators, op)
for op in ('add', 'mul', 'sub',
-# start Py2K
-# 'div',
-# end Py2K
+ 'div',
'mod', 'truediv',
'lt', 'le', 'ne', 'gt', 'ge', 'eq'))
func_vars = util.format_argspec_init(original__init__, grouped=False)
func_text = func_body % func_vars
-# start Py3K
- func_defaults = getattr(original__init__, '__defaults__', None)
- func_kw_defaults = getattr(original__init__, '__kwdefaults__', None)
-# end Py3K
-# start Py2K
-# func = getattr(original__init__, 'im_func', original__init__)
-# func_defaults = getattr(func, 'func_defaults', None)
-# end Py2K
+ if util.py2k:
+ func = getattr(original__init__, 'im_func', original__init__)
+ func_defaults = getattr(func, 'func_defaults', None)
+ else:
+ func_defaults = getattr(original__init__, '__defaults__', None)
+ func_kw_defaults = getattr(original__init__, '__kwdefaults__', None)
env = locals().copy()
exec(func_text, env)
__init__ = env['__init__']
__init__.__doc__ = original__init__.__doc__
+
if func_defaults:
__init__.__defaults__ = func_defaults
-# start Py3K
- if func_kw_defaults:
+ if not util.py2k and func_kw_defaults:
__init__.__kwdefaults__ = func_kw_defaults
-# end Py3K
+
return __init__
-from ..util import jython, pypy, defaultdict, decorator
+from ..util import jython, pypy, defaultdict, decorator, py2k
import decimal
import gc
import time
def picklers():
picklers = set()
-# start Py2K
-# try:
-# import cPickle
-# picklers.add(cPickle)
-# except ImportError:
-# pass
-# end Py2K
+ if py2k:
+ try:
+ import cPickle
+ picklers.add(cPickle)
+ except ImportError:
+ pass
+
import pickle
picklers.add(pickle)
if hasattr(dictlike, 'iterkeys'):
def iterator():
- for key in dictlike.keys():
+ for key in dictlike.iterkeys():
yield key, getter(key)
return iterator()
elif hasattr(dictlike, 'keys'):
from sqlalchemy import exc as sa_exceptions
+from sqlalchemy import util
from sqlalchemy.testing import fixtures
from sqlalchemy.testing import eq_
-# start Py3K
-Exception = BaseException
-# end Py3K
-# start Py2K
-#from exceptions import StandardError, KeyboardInterrupt, SystemExit
-# end Py2K
+if util.py2k:
+ from exceptions import StandardError, KeyboardInterrupt, SystemExit
+else:
+ Exception = BaseException
class Error(Exception):
d = subdict(a=1, b=2, c=3)
self._ok(d)
-# start Py2K
-# def test_UserDict(self):
-# import UserDict
-# d = UserDict.UserDict(a=1, b=2, c=3)
-# self._ok(d)
-# end Py2K
+ if util.py2k:
+ def test_UserDict(self):
+ import UserDict
+ d = UserDict.UserDict(a=1, b=2, c=3)
+ self._ok(d)
def test_object(self):
self._notok(object())
-# start Py2K
-# def test_duck_1(self):
-# class duck1(object):
-# def iteritems(duck):
-# return iter(self.baseline)
-# self._ok(duck1())
-# end Py2K
+ if util.py2k:
+ def test_duck_1(self):
+ class duck1(object):
+ def iteritems(duck):
+ return iter(self.baseline)
+ self._ok(duck1())
def test_duck_2(self):
class duck2(object):
return list(self.baseline)
self._ok(duck2())
-# start Py2K
-# def test_duck_3(self):
-# class duck3(object):
-# def iterkeys(duck):
-# return iter(['a', 'b', 'c'])
-#
-# def __getitem__(duck, key):
-# return dict(a=1, b=2, c=3).get(key)
-# self._ok(duck3())
-# end Py2K
+ if util.py2k:
+ def test_duck_3(self):
+ class duck3(object):
+ def iterkeys(duck):
+ return iter(['a', 'b', 'c'])
+
+ def __getitem__(duck, key):
+ return dict(a=1, b=2, c=3).get(key)
+ self._ok(duck3())
def test_duck_4(self):
class duck4(object):
class DuckTypeCollectionTest(fixtures.TestBase):
def test_sets(self):
-# start Py2K
-# import sets
-# end Py2K
-
class SetLike(object):
def add(self):
pass
__emulates__ = set
for type_ in (set,
-# start Py2K
-# sets.Set,
-# end Py2K
SetLike,
ForcedSet):
eq_(util.duck_type_collection(type_), set)
instance = type_()
eq_(util.duck_type_collection(instance), set)
- for type_ in (frozenset,
-# start Py2K
-# sets.ImmutableSet
-# end Py2K
- ):
+ for type_ in (frozenset, ):
is_(util.duck_type_collection(type_), None)
instance = type_()
is_(util.duck_type_collection(instance), None)
eq_(set(util.class_hierarchy(A)), set((A, B, C, object)))
eq_(set(util.class_hierarchy(B)), set((A, B, C, object)))
-# start Py2K
-# def test_oldstyle_mixin(self):
-# class A(object):
-# pass
-#
-# class Mixin:
-# pass
-#
-# class B(A, Mixin):
-# pass
-#
-# eq_(set(util.class_hierarchy(B)), set((A, B, object)))
-# eq_(set(util.class_hierarchy(Mixin)), set())
-# eq_(set(util.class_hierarchy(A)), set((A, B, object)))
-# end Py2K
+ if util.py2k:
+ def test_oldstyle_mixin(self):
+ class A(object):
+ pass
+
+ class Mixin:
+ pass
+
+ class B(A, Mixin):
+ pass
+
+ eq_(set(util.class_hierarchy(B)), set((A, B, object)))
+ eq_(set(util.class_hierarchy(Mixin)), set())
+ eq_(set(util.class_hierarchy(A)), set((A, B, object)))
class TestClassProperty(fixtures.TestBase):
)
m = mapper(Foo, foo_t)
class DontCompareMeToString(int):
-# start Py3K
- pass
-# end Py3K
-# start Py2K
-# def __lt__(self, other):
-# assert not isinstance(other, basestring)
-# return int(self) < other
-# end Py2K
+ if util.py2k:
+ def __lt__(self, other):
+ assert not isinstance(other, basestring)
+ return int(self) < other
+
foos = [Foo(id='f%d' % i) for i in range(5)]
states = [attributes.instance_state(f) for f in foos]
Column('ht1b_id', Integer, ForeignKey('ht1.id'), primary_key=True),
Column('value', String(10)))
-# start Py2K
-# def test_baseclass(self):
-# ht1 = self.tables.ht1
-#
-# class OldStyle:
-# pass
-#
-# assert_raises(sa.exc.ArgumentError, mapper, OldStyle, ht1)
-#
-# assert_raises(sa.exc.ArgumentError, mapper, 123)
-#
-# class NoWeakrefSupport(str):
-# pass
-#
-# # TODO: is weakref support detectable without an instance?
-# #self.assertRaises(sa.exc.ArgumentError, mapper, NoWeakrefSupport, t2)
-# end Py2K
+ if util.py2k:
+ def test_baseclass(self):
+ ht1 = self.tables.ht1
+
+ class OldStyle:
+ pass
+
+ assert_raises(sa.exc.ArgumentError, mapper, OldStyle, ht1)
+
+ assert_raises(sa.exc.ArgumentError, mapper, 123)
+
+ class NoWeakrefSupport(str):
+ pass
+
+ # TODO: is weakref support detectable without an instance?
+ #self.assertRaises(sa.exc.ArgumentError, mapper, NoWeakrefSupport, t2)
class _ValueBase(object):
def __init__(self, value='abc', id=None):
-import operator
+from sqlalchemy.sql import operators
from sqlalchemy import MetaData, null, exists, text, union, literal, \
literal_column, func, between, Unicode, desc, and_, bindparam, \
select, distinct, or_, collate
Column('data', Unicode(40)))
try:
metadata.create_all()
-# start Py3K
- ustring = b'petit voix m\xe2\x80\x99a'.decode('utf-8')
-# end Py3K
-# start Py2K
-# ustring = 'petit voix m\xe2\x80\x99a'.decode('utf-8')
-# end Py2K
+ ustring = util.b('petit voix m\xe2\x80\x99a').decode('utf-8')
table.insert().execute(id=ustring, data=ustring)
class LocalFoo(self.classes.Base):
User = self.classes.User
create_session().query(User)
- for (py_op, sql_op) in ((operator.add, '+'), (operator.mul, '*'),
- (operator.sub, '-'),
- # Py3k
- #(operator.truediv, '/'),
-# start Py2K
-# (operator.div, '/'),
-# end Py2K
+ for (py_op, sql_op) in ((operators.add, '+'), (operators.mul, '*'),
+ (operators.sub, '-'),
+ (operators.truediv, '/'),
+ (operators.div, '/'),
):
for (lhs, rhs, res) in (
(5, User.id, ':id_1 %s users.id'),
create_session().query(User)
ualias = aliased(User)
- for (py_op, fwd_op, rev_op) in ((operator.lt, '<', '>'),
- (operator.gt, '>', '<'),
- (operator.eq, '=', '='),
- (operator.ne, '!=', '!='),
- (operator.le, '<=', '>='),
- (operator.ge, '>=', '<=')):
+ for (py_op, fwd_op, rev_op) in ((operators.lt, '<', '>'),
+ (operators.gt, '>', '<'),
+ (operators.eq, '=', '='),
+ (operators.ne, '!=', '!='),
+ (operators.le, '<=', '>='),
+ (operators.ge, '>=', '<=')):
for (lhs, rhs, l_sql, r_sql) in (
('a', User.id, ':id_1', 'users.id'),
('a', literal('b'), ':param_2', ':param_1'), # note swap!
from sqlalchemy.testing import assert_raises, assert_raises_message
-from sqlalchemy.orm import util
+from sqlalchemy.orm import util as orm_util
from sqlalchemy import Column
+from sqlalchemy import util
from sqlalchemy import Integer
from sqlalchemy import MetaData
from sqlalchemy import Table
alias = aliased(Point)
assert Point.zero
-# start Py2K
-# # TODO: what is this testing ??
-# assert not getattr(alias, 'zero')
-# end Py2K
+
+ if util.py2k:
+ # TODO: what is this testing ??
+ assert not getattr(alias, 'zero')
def test_classmethods(self):
class Point(object):
self.func = func
def __get__(self, instance, owner):
if instance is None:
-# start Py3K
- args = (self.func, owner)
-# end Py3K
-# start Py2K
-# args = (self.func, owner, owner.__class__)
-# end Py2K
+ if util.py2k:
+ args = (self.func, owner, owner.__class__)
+ else:
+ args = (self.func, owner)
else:
-# start Py3K
- args = (self.func, instance)
-# end Py3K
-# start Py2K
-# args = (self.func, instance, owner)
-# end Py2K
+ if util.py2k:
+ args = (self.func, instance, owner)
+ else:
+ args = (self.func, instance)
return types.MethodType(*args)
class PropertyDescriptor(object):
mapper(User, users)
- key = util.identity_key(User, [1])
+ key = orm_util.identity_key(User, [1])
eq_(key, (User, (1,)))
- key = util.identity_key(User, ident=[1])
+ key = orm_util.identity_key(User, ident=[1])
eq_(key, (User, (1,)))
def test_identity_key_scalar(self):
mapper(User, users)
- key = util.identity_key(User, 1)
+ key = orm_util.identity_key(User, 1)
eq_(key, (User, (1,)))
- key = util.identity_key(User, ident=1)
+ key = orm_util.identity_key(User, ident=1)
eq_(key, (User, (1,)))
def test_identity_key_2(self):
u = User(name='u1')
s.add(u)
s.flush()
- key = util.identity_key(instance=u)
+ key = orm_util.identity_key(instance=u)
eq_(key, (User, (u.id,)))
def test_identity_key_3(self):
mapper(User, users)
row = {users.c.id: 1, users.c.name: "Frank"}
- key = util.identity_key(User, row=row)
+ key = orm_util.identity_key(User, row=row)
eq_(key, (User, (1,)))
def test_root_registry(self):
umapper = inspect(self.classes.User)
is_(
- util.RootRegistry()[umapper],
+ orm_util.RootRegistry()[umapper],
umapper._path_registry
)
eq_(
- util.RootRegistry()[umapper],
- util.PathRegistry.coerce((umapper,))
+ orm_util.RootRegistry()[umapper],
+ orm_util.PathRegistry.coerce((umapper,))
)
def test_expand(self):
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
