from .base import FBDialect, FBExecutionContext
from ... import util, types as sqltypes
-from ...util.compat import decimal
from re import match
+import decimal
class _FBNumeric_kinterbasdb(sqltypes.Numeric):
from .base import MSExecutionContext, MSDialect
from ...connectors.pyodbc import PyODBCConnector
from ... import types as sqltypes, util
-from ...util.compat import decimal
+import decimal
class _MSNumeric_pyodbc(sqltypes.Numeric):
from sqlalchemy import types as sqltypes, util, exc, processors
import random
import collections
-from sqlalchemy.util.compat import decimal
+import decimal
import re
"""
from ... import util, exc
-from ...util.compat import decimal
+import decimal
from ... import processors
from ... import types as sqltypes
from .base import PGDialect, \
import logging
from ... import util, exc
-from ...util.compat import decimal
+import decimal
from ... import processors
from ...engine import result as _result
from ...sql import expression
SybaseExecutionContext
from sqlalchemy.connectors.pyodbc import PyODBCConnector
from sqlalchemy import types as sqltypes, processors
-from sqlalchemy.util.compat import decimal
+import decimal
class _SybNumeric_pyodbc(sqltypes.Numeric):
state, state.dict, col, val)
-class _ColumnMapping(util.py25_dict):
+class _ColumnMapping(dict):
"""Error reporting helper for mapper._columntoproperty."""
def __init__(self, mapper):
self._overflow = 0 - pool_size
self._max_overflow = max_overflow
self._timeout = timeout
- self._overflow_lock = self._max_overflow > -1 and \
- threading.Lock() or DummyLock()
+ self._overflow_lock = threading.Lock() if self._max_overflow > -1 \
+ else DummyLock()
def _do_return_conn(self, conn):
try:
import time
import collections
from .. import util
+
try:
import cProfile
except ImportError:
cProfile = None
-from ..util.compat import jython, pypy, win32
+from ..util import jython, pypy, win32, update_wrapper
_current_test = None
profile_f.write("%s %s %s\n" % (test_key, platform_key, c))
profile_f.close()
-from sqlalchemy.util.compat import update_wrapper
def function_call_count(variance=0.05):
from ..util import jython, pypy, defaultdict, decorator
-from ..util.compat import decimal
-
+import decimal
import gc
import time
import random
from . import exc, schema, util, processors, events, event
from .sql import operators
-from .sql.expression import _DefaultColumnComparator, column, bindparam
+from .sql.expression import _DefaultColumnComparator
from .util import pickle
-from .util.compat import decimal
from .sql.visitors import Visitable
+import decimal
default = util.importlater("sqlalchemy.engine", "default")
NoneType = type(None)
implementations however, most of which contain an import for plain
``decimal`` in their source code, even though some such as psycopg2
provide hooks for alternate adapters. SQLAlchemy imports ``decimal``
- globally as well. While the alternate ``Decimal`` class can be patched
- into SQLA's ``decimal`` module, overall the most straightforward and
+ globally as well. The most straightforward and
foolproof way to use "cdecimal" given current DBAPI and Python support
is to patch it directly into sys.modules before anything else is
imported::
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
-from .compat import callable, cmp, reduce, defaultdict, py25_dict, \
+from .compat import callable, cmp, reduce, \
threading, py3k, py3k_warning, jython, pypy, cpython, win32, set_types, \
- buffer, pickle, update_wrapper, partial, md5_hex, decode_slice, \
- dottedgetter, parse_qsl, any, contextmanager, namedtuple, next, WeakSet
+ pickle, dottedgetter, parse_qsl, namedtuple, next, WeakSet
from ._collections import KeyedTuple, ImmutableContainer, immutabledict, \
Properties, OrderedProperties, ImmutableProperties, OrderedDict, \
portable_instancemethod, unbound_method_to_callable, \
getargspec_init, format_argspec_init, format_argspec_plus, \
get_func_kwargs, get_cls_kwargs, decorator, as_interface, \
- memoized_property, memoized_instancemethod, \
- group_expirable_memoized_property, importlater, \
+ memoized_property, memoized_instancemethod, md5_hex, \
+ group_expirable_memoized_property, importlater, decode_slice, \
monkeypatch_proxied_specials, asbool, bool_or_str, coerce_kw_type,\
duck_type_collection, assert_arg_type, symbol, dictlike_iteritems,\
classproperty, set_creation_order, warn_exception, warn, NoneType,\
from .deprecations import warn_deprecated, warn_pending_deprecation, \
deprecated, pending_deprecation
+
+# things that used to be not always available,
+# but are now as of current support Python versions
+from collections import defaultdict
+from functools import partial
+from functools import update_wrapper
+from contextlib import contextmanager
"""Collection classes and helpers."""
-import sys
import itertools
import weakref
import operator
self.add(o)
-if sys.version_info >= (2, 5):
- class PopulateDict(dict):
- """A dict which populates missing values via a creation function.
+class PopulateDict(dict):
+ """A dict which populates missing values via a creation function.
- Note the creation function takes a key, unlike
- collections.defaultdict.
+ Note the creation function takes a key, unlike
+ collections.defaultdict.
- """
-
- def __init__(self, creator):
- self.creator = creator
-
- def __missing__(self, key):
- self[key] = val = self.creator(key)
- return val
-else:
- class PopulateDict(dict):
- """A dict which populates missing values via a creation function."""
+ """
- def __init__(self, creator):
- self.creator = creator
+ def __init__(self, creator):
+ self.creator = creator
- def __getitem__(self, key):
- try:
- return dict.__getitem__(self, key)
- except KeyError:
- self[key] = value = self.creator(key)
- return value
+ def __missing__(self, key):
+ self[key] = val = self.creator(key)
+ return val
-# define collections that are capable of storing
+# Define collections that are capable of storing
# ColumnElement objects as hashable keys/elements.
+# At this point, these are mostly historical, things
+# used to be more complicated.
column_set = set
column_dict = dict
ordered_column_set = OrderedSet
except ImportError:
import pickle
-
-# a controversial feature, required by MySQLdb currently
-def buffer(x):
- return x
-
-# Py2K
-buffer = buffer
-# end Py2K
-
-try:
- from contextlib import contextmanager
-except ImportError:
- def contextmanager(fn):
- return fn
-
-try:
- from functools import update_wrapper
-except ImportError:
- def update_wrapper(wrapper, wrapped,
- assigned=('__doc__', '__module__', '__name__'),
- updated=('__dict__',)):
- for attr in assigned:
- setattr(wrapper, attr, getattr(wrapped, attr))
- for attr in updated:
- getattr(wrapper, attr).update(getattr(wrapped, attr, ()))
- return wrapper
-
-try:
- from functools import partial
-except ImportError:
- def partial(func, *args, **keywords):
- def newfunc(*fargs, **fkeywords):
- newkeywords = keywords.copy()
- newkeywords.update(fkeywords)
- return func(*(args + fargs), **newkeywords)
- return newfunc
-
-
if sys.version_info < (2, 6):
# emits a nasty deprecation warning
# in newer pythons
tuptype = type(typename, (tuple, ), {'__new__': __new__})
return tuptype
-try:
- from collections import defaultdict
-except ImportError:
- class defaultdict(dict):
-
- def __init__(self, default_factory=None, *a, **kw):
- if (default_factory is not None and
- not hasattr(default_factory, '__call__')):
- raise TypeError('first argument must be callable')
- dict.__init__(self, *a, **kw)
- self.default_factory = default_factory
-
- def __getitem__(self, key):
- try:
- return dict.__getitem__(self, key)
- except KeyError:
- return self.__missing__(key)
-
- def __missing__(self, key):
- if self.default_factory is None:
- raise KeyError(key)
- self[key] = value = self.default_factory()
- return value
-
- def __reduce__(self):
- if self.default_factory is None:
- args = tuple()
- else:
- args = self.default_factory,
- return type(self), args, None, None, self.iteritems()
-
- def copy(self):
- return self.__copy__()
-
- def __copy__(self):
- return type(self)(self.default_factory, self)
-
- def __deepcopy__(self, memo):
- import copy
- return type(self)(self.default_factory,
- copy.deepcopy(self.items()))
-
- def __repr__(self):
- return 'defaultdict(%s, %s)' % (self.default_factory,
- dict.__repr__(self))
-
try:
from weakref import WeakSet
except:
def add(self, other):
self._storage[other] = True
-
-# find or create a dict implementation that supports __missing__
-class _probe(dict):
- def __missing__(self, key):
- return 1
-
-try:
- try:
- _probe()['missing']
- py25_dict = dict
- except KeyError:
- class py25_dict(dict):
- def __getitem__(self, key):
- try:
- return dict.__getitem__(self, key)
- except KeyError:
- try:
- missing = self.__missing__
- except AttributeError:
- raise KeyError(key)
- else:
- return missing(key)
-finally:
- del _probe
-
-
-try:
- import hashlib
- _md5 = hashlib.md5
-except ImportError:
- import md5
- _md5 = md5.new
-
-
-def md5_hex(x):
- # Py3K
- #x = x.encode('utf-8')
- m = _md5()
- m.update(x)
- return m.hexdigest()
-
import time
if win32 or jython:
time_func = time.clock
else:
time_func = time.time
-if sys.version_info >= (2, 5):
- any = any
-else:
- def any(iterator):
- for item in iterator:
- if bool(item):
- return True
- else:
- return False
-
-if sys.version_info >= (2, 5):
- def decode_slice(slc):
- """decode a slice object as sent to __getitem__.
-
- takes into account the 2.5 __index__() method, basically.
-
- """
- ret = []
- for x in slc.start, slc.stop, slc.step:
- if hasattr(x, '__index__'):
- x = x.__index__()
- ret.append(x)
- return tuple(ret)
-else:
- def decode_slice(slc):
- return (slc.start, slc.stop, slc.step)
if sys.version_info >= (2, 6):
from operator import attrgetter as dottedgetter
return obj
return g
-
-import decimal
import sys
import types
import warnings
-from .compat import update_wrapper, set_types, threading, \
+from .compat import set_types, threading, \
callable, inspect_getfullargspec
+from functools import update_wrapper
from .. import exc
+import hashlib
+def md5_hex(x):
+ # Py3K
+ #x = x.encode('utf-8')
+ m = hashlib.md5()
+ m.update(x)
+ return m.hexdigest()
+
+def decode_slice(slc):
+ """decode a slice object as sent to __getitem__.
+
+ takes into account the 2.5 __index__() method, basically.
+
+ """
+ ret = []
+ for x in slc.start, slc.stop, slc.step:
+ if hasattr(x, '__index__'):
+ x = x.__index__()
+ ret.append(x)
+ return tuple(ret)
def _unique_symbols(used, *bases):
used = set(used)
ctr = class_.__dict__.get('__init__', False)
if (not ctr or
not isinstance(ctr, types.FunctionType) or
- not isinstance(ctr.func_code, types.CodeType)):
+ not isinstance(ctr.func_code, types.CodeType)):
stack.update(class_.__bases__)
continue
try:
return format_argspec_plus(method, grouped=grouped)
except TypeError:
- self_arg = 'self'
if method is object.__init__:
args = grouped and '(self)' or 'self'
else:
if hasattr(specimen, '__emulates__'):
# canonicalize set vs sets.Set to a standard: the builtin set
if (specimen.__emulates__ is not None and
- issubclass(specimen.__emulates__, set_types)):
+ issubclass(specimen.__emulates__, set_types)):
return set
else:
return specimen.__emulates__
def find_cycles(tuples, allitems):
- # straight from gvr with some mods
+ # adapted from:
+ # http://neopythonic.blogspot.com/2009/01/detecting-cycles-in-directed-graph.html
edges = util.defaultdict(set)
for parent, child in tuples:
from sqlalchemy.processors import to_decimal_processor_factory, \
to_unicode_processor_factory
from sqlalchemy.testing.util import gc_collect
-from sqlalchemy.util.compat import decimal
+import decimal
import gc
from sqlalchemy.testing import fixtures
import weakref
from sqlalchemy.testing import fixtures, AssertsCompiledSQL, \
AssertsExecutionResults, ComparesTables
from sqlalchemy import testing
-from sqlalchemy.testing import eq_, emits_warning_on, \
- assert_raises_message
-from sqlalchemy.util.compat import decimal
+from sqlalchemy.testing import emits_warning_on, assert_raises_message
+import decimal
from sqlalchemy.engine.reflection import Inspector
class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
from sqlalchemy.sql import table, column
from sqlalchemy.testing import fixtures, AssertsExecutionResults, AssertsCompiledSQL
from sqlalchemy import testing
-from sqlalchemy.testing import eq_, assert_raises, assert_raises_message
+from sqlalchemy.testing import assert_raises, assert_raises_message
from sqlalchemy.testing.engines import testing_engine
from sqlalchemy.dialects.oracle import cx_oracle, base as oracle
from sqlalchemy.engine import default
-from sqlalchemy.util import jython
-from sqlalchemy.util.compat import decimal
+import decimal
from sqlalchemy.testing.schema import Table, Column
import datetime
import os
from sqlalchemy.orm import Session, mapper, aliased
from sqlalchemy import exc, schema, types
from sqlalchemy.dialects.postgresql import base as postgresql
-from sqlalchemy.dialects.postgresql import HSTORE, hstore, array, ARRAY
-from sqlalchemy.util.compat import decimal
+from sqlalchemy.dialects.postgresql import HSTORE, hstore, array
+import decimal
from sqlalchemy.testing.util import round_decimal
from sqlalchemy.sql import table, column, operators
import logging
def test_numeric_codes(self):
from sqlalchemy.dialects.postgresql import pg8000, psycopg2, base
- from sqlalchemy.util.compat import decimal
for dialect in (pg8000.dialect(), psycopg2.dialect()):
from sqlalchemy import testing
from sqlalchemy.orm import mapper, relationship, create_session
from sqlalchemy import util
-from sqlalchemy.util import any
import sqlalchemy as sa
from sqlalchemy.testing import eq_, assert_raises_message
# -*- encoding: utf8 -*-
from datetime import *
-from sqlalchemy.util.compat import decimal
+import decimal
#from fastdec import mpd as Decimal
from cPickle import dumps, loads
from sqlalchemy import types as sqltypes
from sqlalchemy.sql import functions
from sqlalchemy.sql.functions import GenericFunction
-from sqlalchemy.util.compat import decimal
+import decimal
from sqlalchemy import testing
from sqlalchemy.testing import fixtures, AssertsCompiledSQL, engines
from sqlalchemy.dialects import sqlite, postgresql, mysql, oracle
from sqlalchemy.testing import AssertsCompiledSQL, AssertsExecutionResults, \
engines, pickleable
from sqlalchemy.testing.util import picklers
-from sqlalchemy.util.compat import decimal
from sqlalchemy.testing.util import round_decimal
from sqlalchemy.testing import fixtures
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
