1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
import io
import sys
from sqlalchemy import __version__ as sa_version
if sys.version_info < (2, 6):
raise NotImplementedError("Python 2.6 or greater is required.")
sqla_08 = sa_version >= '0.8.0'
sqla_09 = sa_version >= '0.9.0'
py2k = sys.version_info < (3, 0)
py3k = sys.version_info >= (3, 0)
py33 = sys.version_info >= (3, 3)
if py3k:
import builtins as compat_builtins
string_types = str,
binary_type = bytes
text_type = str
def callable(fn):
return hasattr(fn, '__call__')
def u(s):
return s
else:
import __builtin__ as compat_builtins
string_types = basestring,
binary_type = str
text_type = unicode
callable = callable
def u(s):
return unicode(s, "utf-8")
if py3k:
from configparser import ConfigParser as SafeConfigParser
import configparser
else:
from ConfigParser import SafeConfigParser
import ConfigParser as configparser
if py2k:
from mako.util import parse_encoding
if py33:
from importlib import machinery
def load_module_py(module_id, path):
return machinery.SourceFileLoader(module_id, path).load_module(module_id)
def load_module_pyc(module_id, path):
return machinery.SourcelessFileLoader(module_id, path).load_module(module_id)
else:
import imp
def load_module_py(module_id, path):
with open(path, 'rb') as fp:
mod = imp.load_source(module_id, path, fp)
if py2k:
source_encoding = parse_encoding(fp)
if source_encoding:
mod._alembic_source_encoding = source_encoding
return mod
def load_module_pyc(module_id, path):
with open(path, 'rb') as fp:
mod = imp.load_compiled(module_id, path, fp)
# no source encoding here
return mod
try:
exec_ = getattr(compat_builtins, 'exec')
except AttributeError:
# Python 2
def exec_(func_text, globals_, lcl):
exec('exec func_text in globals_, lcl')
################################################
# cross-compatible metaclass implementation
# Copyright (c) 2010-2012 Benjamin Peterson
def with_metaclass(meta, base=object):
"""Create a base class with a metaclass."""
return meta("%sBase" % meta.__name__, (base,), {})
################################################
# produce a wrapper that allows encoded text to stream
# into a given buffer, but doesn't close it.
# not sure of a more idiomatic approach to this.
class EncodedIO(io.TextIOWrapper):
def close(self):
pass
if py2k:
# in Py2K, the io.* package is awkward because it does not
# easily wrap the file type (e.g. sys.stdout) and I can't
# figure out at all how to wrap StringIO.StringIO (used by nosetests)
# and also might be user specified too. So create a full
# adapter.
class ActLikePy3kIO(object):
"""Produce an object capable of wrapping either
sys.stdout (e.g. file) *or* StringIO.StringIO().
"""
def _false(self):
return False
def _true(self):
return True
readable = seekable = _false
writable = _true
closed = False
def __init__(self, file_):
self.file_ = file_
def write(self, text):
return self.file_.write(text)
def flush(self):
return self.file_.flush()
class EncodedIO(EncodedIO):
def __init__(self, file_, encoding):
super(EncodedIO, self).__init__(
ActLikePy3kIO(file_), encoding=encoding)
|