sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/compat.py

@@ -0,0 +1,59 @@
+import os
+import sys
+import types
+
+# Credit to six authors: https://pypi.org/project/six/
+# License: MIT
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+
+    class metaclass(meta):
+        def __new__(cls, name, this_bases, d):
+            return meta(name, bases, d)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+# Compatability definitions (inspired by six)
+PY2 = sys.version_info[0] < 3
+if PY2:
+    # disable flake8 checks on python 3
+    string_type = basestring  # noqa
+    unicode_type = unicode  # noqa
+    class_types = (type, types.ClassType)
+    buffer_type = buffer  # noqa
+else:
+    string_type = str
+    unicode_type = str
+    class_types = (type,)
+    buffer_type = memoryview
+
+if PY2:
+    import imp
+
+    def load_module_from_file(base_name, module_name, filename):
+        fp, pathname, description = imp.find_module(
+            base_name, [os.path.dirname(filename)])
+        try:
+            module = imp.load_module(module_name, fp, pathname, description)
+        finally:
+            fp.close()
+        return module
+else:
+    import importlib.util
+
+    def load_module_from_file(base_name, module_name, filename):
+        specs = importlib.util.spec_from_file_location(module_name, filename)
+        loader = specs.loader
+        if hasattr(loader, 'create_module'):
+            module = loader.create_module(specs)
+        else:
+            module = None
+        if module is None:
+            return specs.loader.load_module()
+        else:
+            loader.exec_module(module)
+            return module

sqlobject/conftest.py

@@ -0,0 +1,64 @@
+"""This module is used by pytest to configure testing"""
+
+try:
+    import pkg_resources
+except ImportError:
+    pass
+else:
+    pkg_resources.require('SQLObject')
+
+# Override some options (doesn't override command line):
+verbose = 0
+exitfirst = True
+
+connectionShortcuts = {
+    'mysql': 'mysql://test@localhost/test',
+    'dbm': 'dbm:///data',
+    'postgres': 'postgres:///test',
+    'postgresql': 'postgres:///test',
+    'pygresql': 'pygresql://localhost/test',
+    'sqlite': 'sqlite:/:memory:',
+    'sybase': 'sybase://test:test123@sybase/test?autoCommit=0',
+    'firebird':
+        'firebird://sysdba:masterkey@localhost/var/lib/firebird/data/test.gdb',
+    'mssql': 'mssql://sa:@127.0.0.1/test'
+}
+
+
+def pytest_addoption(parser):
+    """Add the SQLObject options"""
+    parser.addoption(
+        '-D', '--Database',
+        action="store", dest="Database", default='sqlite',
+        help="The database to run the tests under (default sqlite).  "
+        "Can also use an alias from: %s"
+        % (', '.join(connectionShortcuts.keys())))
+    parser.addoption(
+        '-S', '--SQL',
+        action="store_true", dest="show_sql", default=False,
+        help="Show SQL from statements (when capturing stdout the "
+        "SQL is only displayed when a test fails)")
+    parser.addoption(
+        '-O', '--SQL-output',
+        action="store_true", dest="show_sql_output", default=False,
+        help="Show output from SQL statements (when capturing "
+        "stdout the output is only displayed when a test fails)")
+    parser.addoption(
+        '-E', '--events',
+        action="store_true", dest="debug_events", default=False,
+        help="Debug events (print information about events as they are "
+        "sent)")
+
+option = None
+
+
+def pytest_configure(config):
+    """Make cmdline arguments available to dbtest"""
+    global option
+    option = config.option
+
+
+def setup_tests():
+    if option.debug_events:
+        from sqlobject import events
+        events.debug_events()

sqlobject/constraints.py

@@ -0,0 +1,77 @@
+"""
+Constraints
+"""
+
+from sqlobject.compat import PY2
+
+if not PY2:
+    # alias for python 3 compatability
+    long = int
+
+
+class BadValue(ValueError):
+
+    def __init__(self, desc, obj, col, value, *args):
+        self.desc = desc
+        self.col = col
+
+        # I want these objects to be garbage-collectable, so
+        # I just keep their repr:
+        self.obj = repr(obj)
+        self.value = repr(value)
+        fullDesc = "%s.%s %s (you gave: %s)" \
+                   % (obj, col.name, desc, value)
+        ValueError.__init__(self, fullDesc, *args)
+
+
+def isString(obj, col, value):
+    if not isinstance(value, str):
+        raise BadValue("only allows strings", obj, col, value)
+
+
+def notNull(obj, col, value):
+    if value is None:
+        raise BadValue("is defined NOT NULL", obj, col, value)
+
+
+def isInt(obj, col, value):
+    if not isinstance(value, (int, long)):
+        raise BadValue("only allows integers", obj, col, value)
+
+
+def isFloat(obj, col, value):
+    if not isinstance(value, (int, long, float)):
+        raise BadValue("only allows floating point numbers", obj, col, value)
+
+
+def isBool(obj, col, value):
+    if not isinstance(value, bool):
+        raise BadValue("only allows booleans", obj, col, value)
+
+
+class InList:
+
+    def __init__(self, _l):
+        self.list = _l
+
+    def __call__(self, obj, col, value):
+        if value not in self.list:
+            raise BadValue("accepts only values in %s" % repr(self.list),
+                           obj, col, value)
+
+
+class MaxLength:
+
+    def __init__(self, length):
+        self.length = length
+
+    def __call__(self, obj, col, value):
+        try:
+            length = len(value)
+        except TypeError:
+            raise BadValue("object does not have a length",
+                           obj, col, value)
+        if length > self.length:
+            raise BadValue("must be shorter in length than %s"
+                           % self.length,
+                           obj, col, value)

sqlobject/converters.py

@@ -0,0 +1,278 @@
+from array import array
+import datetime
+from decimal import Decimal
+import time
+import sys
+from .compat import PY2, buffer_type
+
+if PY2:
+    from types import ClassType, InstanceType, NoneType
+else:
+    # Use suitable aliases for now
+    ClassType = type
+    NoneType = type(None)
+    # This is may not be what we want in all cases, but will do for now
+    InstanceType = object
+
+
+try:
+    from mx.DateTime import DateTimeType as mxDateTimeType, \
+        DateTimeDeltaType as mxDateTimeDeltaType
+except ImportError:
+    mxDateTimeType = None
+    mxDateTimeDeltaType = None
+
+try:
+    import pendulum
+except ImportError:
+    pendulumDateTimeType = None
+else:
+    pendulumDateTimeType = pendulum.DateTime
+
+try:
+    from DateTime import DateTime as zopeDateTime
+except ImportError:
+    zopeDateTimeType = None
+else:
+    zopeDateTimeType = type(zopeDateTime())
+
+try:
+    import Sybase
+    NumericType = Sybase.NumericType
+except ImportError:
+    NumericType = None
+
+
+########################################
+# Quoting
+########################################
+
+sqlStringReplace = [
+    ("'", "''"),
+    ('\\', '\\\\'),
+    ('\000', '\\0'),
+    ('\b', '\\b'),
+    ('\n', '\\n'),
+    ('\r', '\\r'),
+    ('\t', '\\t'),
+]
+
+
+class ConverterRegistry:
+
+    def __init__(self):
+        self.basic = {}
+        self.klass = {}
+
+    def registerConverter(self, typ, func):
+        if type(typ) is ClassType:
+            self.klass[typ] = func
+        else:
+            self.basic[typ] = func
+
+    if PY2:
+        def lookupConverter(self, value, default=None):
+            if type(value) is InstanceType:
+                # lookup on klasses dict
+                return self.klass.get(value.__class__, default)
+            return self.basic.get(type(value), default)
+    else:
+        def lookupConverter(self, value, default=None):
+            # python 3 doesn't have classic classes, so everything's
+            # in self.klass due to comparison order in registerConvertor
+            return self.klass.get(value.__class__, default)
+
+converters = ConverterRegistry()
+registerConverter = converters.registerConverter
+lookupConverter = converters.lookupConverter
+
+
+def StringLikeConverter(value, db):
+    if isinstance(value, array):
+        try:
+            value = value.tounicode()
+        except ValueError:
+            value = value.tostring()
+    elif isinstance(value, buffer_type):
+        value = str(value)
+
+    if db in ('mysql', 'postgres'):
+        for orig, repl in sqlStringReplace:
+            value = value.replace(orig, repl)
+    elif db in ('sqlite', 'firebird', 'sybase', 'maxdb', 'mssql'):
+        value = value.replace("'", "''")
+    else:
+        assert 0, "Database %s unknown" % db
+    if (db == 'postgres') and ('\\' in value):
+        return "E'%s'" % value
+    return "'%s'" % value
+
+registerConverter(str, StringLikeConverter)
+if PY2:
+    # noqa for flake8 & python3
+    registerConverter(unicode, StringLikeConverter)  # noqa
+registerConverter(array, StringLikeConverter)
+if PY2:
+    registerConverter(bytearray, StringLikeConverter)
+    registerConverter(buffer_type, StringLikeConverter)
+else:
+    registerConverter(memoryview, StringLikeConverter)
+
+
+def IntConverter(value, db):
+    return repr(int(value))
+
+registerConverter(int, IntConverter)
+
+
+def LongConverter(value, db):
+    return str(value)
+
+if sys.version_info[0] < 3:
+    # noqa for flake8 & python3
+    registerConverter(long, LongConverter)  # noqa
+
+if NumericType:
+    registerConverter(NumericType, IntConverter)
+
+
+def BoolConverter(value, db):
+    if db == 'postgres':
+        if value:
+            return "'t'"
+        else:
+            return "'f'"
+    else:
+        if value:
+            return '1'
+        else:
+            return '0'
+
+registerConverter(bool, BoolConverter)
+
+
+def FloatConverter(value, db):
+    return repr(value)
+
+registerConverter(float, FloatConverter)
+
+
+def NoneConverter(value, db):
+    return "NULL"
+
+registerConverter(NoneType, NoneConverter)
+
+
+def SequenceConverter(value, db):
+    return "(%s)" % ", ".join([sqlrepr(v, db) for v in value])
+
+registerConverter(tuple, SequenceConverter)
+registerConverter(list, SequenceConverter)
+registerConverter(dict, SequenceConverter)
+registerConverter(set, SequenceConverter)
+registerConverter(frozenset, SequenceConverter)
+
+if hasattr(time, 'struct_time'):
+    def StructTimeConverter(value, db):
+        return time.strftime("'%Y-%m-%d %H:%M:%S'", value)
+
+    registerConverter(time.struct_time, StructTimeConverter)
+
+
+def DateTimeConverter(value, db):
+    return "'%04d-%02d-%02d %02d:%02d:%02d'" % (
+        value.year, value.month, value.day,
+        value.hour, value.minute, value.second)
+
+
+def DateTimeConverterMS(value, db):
+    return "'%04d-%02d-%02d %02d:%02d:%02d.%06d'" % (
+        value.year, value.month, value.day,
+        value.hour, value.minute, value.second, value.microsecond)
+
+registerConverter(datetime.datetime, DateTimeConverterMS)
+
+
+def DateConverter(value, db):
+    return "'%04d-%02d-%02d'" % (value.year, value.month, value.day)
+
+registerConverter(datetime.date, DateConverter)
+
+
+def TimeConverter(value, db):
+    return "'%02d:%02d:%02d'" % (value.hour, value.minute, value.second)
+
+
+def TimeConverterMS(value, db):
+    return "'%02d:%02d:%02d.%06d'" % (value.hour, value.minute,
+                                      value.second, value.microsecond)
+
+registerConverter(datetime.time, TimeConverterMS)
+
+
+if mxDateTimeType:
+    def mxDateTimeConverter(value, db):
+        return "'%s'" % value.strftime("%Y-%m-%d %H:%M:%S")
+
+    registerConverter(mxDateTimeType, mxDateTimeConverter)
+
+    def mxTimeConverter(value, db):
+        return "'%s'" % value.strftime("%H:%M:%S")
+
+    registerConverter(mxDateTimeDeltaType, mxTimeConverter)
+
+
+if pendulumDateTimeType:
+    def pendulumConverter(value, db):
+        return "'%s'" % value.to_datetime_string()
+
+    registerConverter(pendulum.DateTime, pendulumConverter)
+
+
+if zopeDateTimeType:
+    def zopeDateTimeConverter(value, db):
+        return "'%s'" % value.strftime("%Y-%m-%d %H:%M:%S")
+
+    registerConverter(zopeDateTimeType, zopeDateTimeConverter)
+
+
+def DecimalConverter(value, db):
+    return value.to_eng_string()
+
+registerConverter(Decimal, DecimalConverter)
+
+
+def TimedeltaConverter(value, db):
+
+    return """INTERVAL '%d days %d seconds'""" % \
+        (value.days, value.seconds)
+
+registerConverter(datetime.timedelta, TimedeltaConverter)
+
+
+def sqlrepr(obj, db=None):
+    try:
+        reprFunc = obj.__sqlrepr__
+    except AttributeError:
+        converter = lookupConverter(obj)
+        if converter is None:
+            raise ValueError("Unknown SQL builtin type: %s for %s" %
+                             (type(obj), repr(obj)))
+        return converter(obj, db)
+    else:
+        return reprFunc(db)
+
+
+def quote_str(s, db):
+    if (db == 'postgres') and ('\\' in s):
+        return "E'%s'" % s
+    return "'%s'" % s
+
+
+def unquote_str(s):
+    if s[:2].upper().startswith("E'") and s.endswith("'"):
+        return s[2:-1]
+    elif s.startswith("'") and s.endswith("'"):
+        return s[1:-1]
+    else:
+        return s