Initial commit

Author: dahlia

.gitignore

@@ -0,0 +1,6 @@
+*.egg-info
+*.egg
+*.pyc
+.*.swp
+.eggs/
+.tox/

LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2015 by Hong Minhee <http://hongminhee.org/>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

setup.cfg

@@ -0,0 +1,2 @@
+[bdist_wheel]
+universal = 1

setup.py

@@ -0,0 +1,67 @@
+import ast
+import os.path
+import sys
+
+from setuptools import setup
+
+
+def get_version():
+    module_path = os.path.join(os.path.dirname(__file__),
+                               'sqlalchemy_enum34.py')
+    module_file = open(module_path)
+    try:
+        module_code = module_file.read()
+    finally:
+        module_file.close()
+    tree = ast.parse(module_code, module_path)
+    for node in ast.iter_child_nodes(tree):
+        if not isinstance(node, ast.Assign) or len(node.targets) != 1:
+            continue
+        target, = node.targets
+        if isinstance(target, ast.Name) and target.id == '__version__':
+            return node.value.s
+
+
+def get_install_requires():
+    install_requires = ['setuptools', 'SQLAlchemy >= 0.8.0']
+    if 'bdist_wheel' not in sys.argv and sys.version_info < (3, 4):
+        install_requires.append('enum34')
+    return install_requires
+
+
+def get_extras_require():
+    """Generate conditional requirements with environ marker."""
+    for pyversion in '2.5', '2.6', '2.7', '3.2', '3.3':
+        yield ':python_version==' + repr(pyversion), ['enum34']
+
+
+setup(
+    name='SQLAlchemy-Enum34',
+    description='SQLAlchemy type to store standard enum.Enum value',
+    version=get_version(),
+    url='https://github.com/spoqa/sqlalchemy-enum34',
+    author='Hong Minhee',
+    author_email='hongminhee' '@' 'member.fsf.org',
+    license='MIT License',
+    py_modules=['sqlalchemy_enum34'],
+    install_requires=get_install_requires(),
+    extras_require=dict(get_extras_require()),
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python :: 2.6',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3.2',
+        'Programming Language :: Python :: 3.3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: Implementation :: CPython',
+        'Programming Language :: Python :: Implementation :: PyPy',
+        'Programming Language :: Python :: Implementation :: Stackless',
+        'Programming Language :: SQL',
+        'Topic :: Database :: Front-Ends',
+        'Topic :: Software Development',
+    ]
+)

sqlalchemy_enum34.py

@@ -0,0 +1,62 @@
+""":mod:`sqlalchemy_enum34` --- SQLAlchemy :class:`enum` type
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+"""
+import enum
+
+from sqlalchemy.types import Enum as BaseEnum, SchemaType, TypeDecorator
+
+__all__ = 'Enum', 'EnumType'
+__version__ = '1.0.0'
+
+
+class Enum(TypeDecorator, SchemaType):
+    """Store :class:`enum.Enum` in the standard library (introduced in Python
+    3.4).  Its internal representation is equivalent to SQLAlchemy's built-in
+    :class:`~sqlalchemy.types.Enum`, but its Python representation is not
+    a :class:`str` but :class:`enum.Enum`.
+
+    :param enum_class: the :class:`enum.Enum` subclass
+    :type enum_class: :class:`type`
+    :param by_name: whether to store values by its name instead of its value.
+                    :const:`False` by default
+    :type by_name: :class:`bool`
+    :param \*\*options: rest keyword arguments will be passed to
+                        :class:`~sqlalchemy.types.Enum` constructor
+
+    """
+
+    impl = BaseEnum
+
+    def __init__(self, enum_class, by_name=False, **options):
+        if not issubclass(enum_class, enum.Enum):
+            raise TypeError('expected enum.Enum subtype')
+        if by_name:
+            enumerants = [m.name for m in enum_class]
+        else:
+            enumerants = [m.value for m in enum_class]
+        super(Enum, self).__init__(*enumerants, **options)
+        self._enum_class = enum_class
+        self._by_name = bool(by_name)
+
+    def process_bind_param(self, value, dialect):
+        if self._by_name:
+            return value.name
+        return value.value
+
+    def process_result_value(self, value, dialect):
+        if self._by_name:
+            return self._enum_class[value]
+        return self._enum_class(value)
+
+    def _set_parent(self, column):
+        self.impl._set_parent(column)
+
+    @property
+    def python_type(self):
+        return self._enum_class
+
+
+#: Alias of :class:`Enum`.  Can used for disambiguating from
+#: :class:`enum.Enum` when their names get duplicated.
+EnumType = Enum

test.py

@@ -0,0 +1,120 @@
+import enum
+import os
+
+from pytest import fixture, yield_fixture
+from sqlalchemy.engine import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import NullPool
+from sqlalchemy.schema import Column
+from sqlalchemy.types import Integer
+
+from sqlalchemy_enum34 import Enum, EnumType
+
+
+Base = declarative_base()
+Session = sessionmaker()
+
+
+class Color(enum.Enum):
+
+    red = 'r'
+    green = 'g'
+    blue = 'b'
+
+
+class ColorTable(Base):
+
+    id = Column(Integer, primary_key=True)
+    color_by_val = Column(Enum(Color, name='color_by_val'))
+    color_by_name = Column(Enum(Color, by_name=True, name='color_by_name'))
+
+    __tablename__ = 'tb_color'
+
+
+try:
+    database_urls = os.environ['TEST_DATABASE_URLS'].split()
+except KeyError:
+    database_urls = []
+
+
+@fixture(scope='function', params=['sqlite://'] + database_urls)
+def fx_engine(request):
+    url = request.param
+    engine = create_engine(url, poolclass=NullPool)
+    request.addfinalizer(engine.dispose)
+    return engine
+
+
+@yield_fixture
+def fx_connection(fx_engine):
+    connection = fx_engine.connect()
+    try:
+        transaction = connection.begin()
+        try:
+            metadata = Base.metadata
+            metadata.create_all(bind=connection)
+            yield connection
+        finally:
+            transaction.rollback()
+    finally:
+        connection.close()
+
+
+@yield_fixture
+def fx_session(fx_connection):
+    session = Session(bind=fx_connection)
+    try:
+        yield session
+    finally:
+        session.close()
+
+
+@fixture
+def fx_red(fx_session):
+    red = ColorTable(color_by_val=Color.red, color_by_name=Color.red)
+    fx_session.add(red)
+    fx_session.flush()
+    return red
+
+
+@fixture
+def fx_green(fx_session):
+    green = ColorTable(color_by_val=Color.green, color_by_name=Color.green)
+    fx_session.add(green)
+    fx_session.flush()
+    return green
+
+
+@fixture
+def fx_blue(fx_session):
+    blue = ColorTable(color_by_val=Color.blue, color_by_name=Color.blue)
+    fx_session.add(blue)
+    fx_session.flush()
+    return blue
+
+
+def test_enum_by_value(fx_session, fx_blue, fx_red):
+    result = fx_session.query(ColorTable) \
+                       .filter_by(color_by_val=Color.blue) \
+                       .one()
+    assert fx_blue is result
+    result2 = fx_session.query(ColorTable) \
+                        .filter("tb_color.color_by_val = 'r'") \
+                        .one()
+    assert fx_red is result2
+
+
+def test_enum_by_name(fx_session, fx_green, fx_blue):
+    result = fx_session.query(ColorTable) \
+                       .filter_by(color_by_name=Color.green) \
+                       .one()
+    assert fx_green is result
+    result2 = fx_session.query(ColorTable) \
+                        .filter("tb_color.color_by_name = 'blue'") \
+                        .one()
+    assert fx_blue is result2
+
+
+def test_enum_is_enum_type():
+    assert Enum is EnumType

tox.ini

@@ -0,0 +1,14 @@
+[tox]
+envlist = pypy, py26, py27, py32, pypy3, py33, py34
+minversion = 1.6.0
+
+[testenv]
+deps =
+    pytest
+    flake8
+commands =
+    py.test test.py
+    flake8 .
+
+[flake8]
+filename = sqlalchemy_enum34.py,test*.py