from sqlalchemy import types as sqltypes
from sqlalchemy import util
from sqlalchemy.sql import compiler, functions as sql_functions
-from types import NoneType
+from sqlalchemy.util import NoneType
class NumericMixin(object):
def bind_processor(self, dialect):
from sqlalchemy.engine import default
from sqlalchemy import types as sqltypes
from sqlalchemy import util
-from types import NoneType
class SQLite_pysqliteExecutionContext(default.DefaultExecutionContext):
def post_exec(self):
for i, item in enumerate(metadata):
colname = item[0]
+ # Py2K
if self.dialect.description_encoding:
colname = colname.decode(self.dialect.description_encoding)
-
+ # end Py2K
+
if '.' in colname:
# sqlite will in some circumstances prepend table name to colnames, so strip
origname = colname
fn(self, index)
_tidy(__delitem__)
return __delitem__
-
+
+ # Py2K
def __setslice__(fn):
def __setslice__(self, start, end, values):
for value in self[start:end]:
fn(self, start, end)
_tidy(__delslice__)
return __delslice__
-
+ # end Py2K
+
def extend(fn):
def extend(self, iterable):
for value in iterable:
pass
_straight_ops = set(getattr(operators, op)
- for op in ('add', 'mul', 'sub', 'div', 'mod', 'truediv',
+ for op in ('add', 'mul', 'sub',
+ # Py2K
+ 'div',
+ # end Py2K
+ 'mod', 'truediv',
'lt', 'le', 'ne', 'gt', 'ge', 'eq'))
return list(self.itervalues())
def all_states(self):
+ # Py3K
+ # return list(dict.values(self))
+
+ # Py2K
return dict.values(self)
+ # end Py2K
def prune(self):
return 0
operators.add : '+',
operators.mul : '*',
operators.sub : '-',
+ # Py2K
operators.div : '/',
+ # end Py2K
operators.mod : '%',
operators.truediv : '/',
operators.lt : '<',
operators.add : (__operate,),
operators.mul : (__operate,),
operators.sub : (__operate,),
+ # Py2K
operators.div : (__operate,),
+ # end Py2K
operators.mod : (__operate,),
operators.truediv : (__operate,),
operators.lt : (__compare, operators.ge),
"""Defines operators used in SQL expressions."""
from operator import (
- and_, or_, inv, add, mul, sub, div, mod, truediv, lt, le, ne, gt, ge, eq
+ and_, or_, inv, add, mul, sub, mod, truediv, lt, le, ne, gt, ge, eq
)
+
+# Py2K
+from operator import (div,)
+# end Py2K
+
from sqlalchemy.util import symbol
_PRECEDENCE = {
from_: 15,
mul: 7,
+ # Py2K
div: 7,
+ # end Py2K
mod: 7,
add: 6,
sub: 6,
from sqlalchemy import exc
try:
- import thread, threading
+ import thread as thread, threading as threading
from threading import local as ThreadLocal
except ImportError:
import dummy_thread as thread
EMPTY_SET = frozenset()
+NoneType = type(None)
+
if py3k:
import pickle
else:
return self._data.keys()
def has_key(self, key):
- return self._data.has_key(key)
+ return key in self._data
def clear(self):
self._data.clear()
import re
py3k_pattern = re.compile(r'\s*# Py3K')
-comment_pattern = re.compile(r'(\s*)#(.*)')
+comment_pattern = re.compile(r'(\s*)#(?! ?Py2K)(.*)')
py2k_pattern = re.compile(r'\s*# Py2K')
end_py2k_pattern = re.compile(r'\s*# end Py2K')
if m:
yield "%s%s" % m.group(1, 2)
else:
- yield line
+ m = py2k_pattern.match(line)
+ if m:
+ for line in consume_py2k():
+ yield line
+ else:
+ yield line
break
def consume_py2k():
return "\n".join(consume_normal())
-refactor_string = main.StdoutRefactoringTool.refactor_string
-main.StdoutRefactoringTool.refactor_string = lambda s, data, name: refactor_string(s, preprocess(data), name)
+old_refactor_string = main.StdoutRefactoringTool.refactor_string
+
+def refactor_string(self, data, name):
+ newdata = preprocess(data)
+ tree = old_refactor_string(self, newdata, name)
+ if tree:
+ if newdata != data:
+ tree.was_changed = True
+ return tree
+
+main.StdoutRefactoringTool.refactor_string = refactor_string
main.main("lib2to3.fixes")
class DuckTypeCollectionTest(TestBase):
+ # Py3K
+ #pass
+
+ # Py2K
def test_sets(self):
import sets
class SetLike(object):
is_(util.duck_type_collection(type_), None)
instance = type_()
is_(util.duck_type_collection(instance), None)
-
+ # end Py2K
class ArgInspectionTest(TestBase):
def test_get_cls_kwargs(self):
import testenv; testenv.configure_for_tests()
-import sets
from sqlalchemy import *
from sqlalchemy import sql, exc
from sqlalchemy.dialects.mysql import base as mysql
self.assert_compile(DropThingy(),
"DROP THINGY"
)
-
+
+ from sqlalchemy.dialects.postgres import base
self.assert_compile(AddThingy(),
"ADD SPECIAL PG THINGY",
- dialect=create_engine('postgres://', _initialize=False).dialect
+ dialect=base.dialect()
)
self.assert_compile(DropThingy(),
"DROP THINGY",
- dialect=create_engine('postgres://', _initialize=False).dialect
+ dialect=base.dialect()
)
direct.remove(e)
control.remove(e)
assert_eq()
-
+
+ # Py2K
if hasattr(direct, '__setslice__'):
values = [creator(), creator()]
direct[0:1] = values
del direct[:]
del control[:]
assert_eq()
-
+ # end Py2K
+
if hasattr(direct, 'extend'):
values = [creator(), creator(), creator()]
@testing.resolve_artifact_names
def test_comparable_column(self):
class MyComparator(sa.orm.properties.ColumnProperty.Comparator):
+ __hash__ = None
def __eq__(self, other):
# lower case comparison
return func.lower(self.__clause_element__()) == func.lower(other)
assert 'populate_instance' not in carrier
carrier.append(interfaces.MapperExtension)
+
+ # Py3K
+ #assert 'populate_instance' not in carrier
+ # Py2K
assert 'populate_instance' in carrier
-
+ # end Py2K
+
assert carrier.interface
for m in carrier.interface:
assert getattr(interfaces.MapperExtension, m)
alias = aliased(Point)
assert Point.zero
+ # Py2K
+ # TODO: what is this testing ??
assert not getattr(alias, 'zero')
+ # end Py2K
def test_classmethods(self):
class Point(object):
self.func = func
def __get__(self, instance, owner):
if instance is None:
+ # Py3K
+ #args = (self.func, owner)
+ # Py2K
args = (self.func, owner, owner.__class__)
+ # end Py2K
else:
+ # Py3K
+ #args = (self.func, instance)
+ # Py2K
args = (self.func, instance, owner)
+ # end Py2K
return types.MethodType(*args)
class PropertyDescriptor(object):
fn.func_defaults, fn.func_closure)
return fn
-try:
- callable = __builtin__.callable
-except NameError:
- def callable(fn): return hasattr(fn, '__call__')
+from sqlalchemy.util import callable
Natives = set([getattr(types, t)
for t in dir(types) if not t.startswith('_')]). \
difference([getattr(types, t)
+ # Py3K
+ #for t in ('FunctionType', 'BuiltinFunctionType',
+ # 'MethodType', 'BuiltinMethodType',
+ # 'LambdaType', )])
+
+ # Py2K
for t in ('FunctionType', 'BuiltinFunctionType',
'MethodType', 'BuiltinMethodType',
'LambdaType', 'UnboundMethodType',)])
+ # end Py2K
def __init__(self):
self.buffer = deque()
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
