Merge pull request #35 from thombashi/develop

Develop

.travis.yml

@@ -2,8 +2,6 @@ language: python
 
 matrix:
   include:
-    - python: 2.6
-      env: TOXENV=python2.6
     - python: 2.7
       env: TOXENV=python2.7
     - python: 3.3

dataproperty/_data_property.py

@@ -9,6 +9,7 @@
 
 from ._align_getter import align_getter
 from ._container import MinMaxContainer
+from ._error import TypeConversionError
 from ._interface import DataPeropertyInterface
 from ._typecode import Typecode
 from ._type_checker import FloatTypeChecker
@@ -18,6 +19,7 @@
 from ._function import get_text_len
 
 from ._factory import NoneTypeFactory
+from ._factory import StringTypeFactory
 from ._factory import IntegerTypeFactory
 from ._factory import FloatTypeFactory
 from ._factory import BoolTypeFactory
@@ -34,7 +36,34 @@ def default_datetime_converter(value):
     return value
 
 
-class DataProperty(DataPeropertyInterface):
+class DataPeropertyBase(DataPeropertyInterface):
+    __slots__ = ("__datetime_format_str")
+
+    @property
+    def format_str(self):
+        format_str = {
+            Typecode.NONE: "",
+            Typecode.INT: "d",
+            Typecode.BOOL: "",
+            Typecode.DATETIME: self.__datetime_format_str,
+        }.get(self.typecode)
+
+        if format_str is not None:
+            return format_str
+
+        if self.typecode in (Typecode.FLOAT, Typecode.INFINITY, Typecode.NAN):
+            if is_nan(self.decimal_places):
+                return "f"
+
+            return ".%df" % (self.decimal_places)
+
+        return "s"
+
+    def __init__(self, datetime_format_str):
+        self.__datetime_format_str = datetime_format_str
+
+
+class DataProperty(DataPeropertyBase):
     __slots__ = (
         "__data",
         "__typecode",
@@ -53,6 +82,7 @@ class DataProperty(DataPeropertyInterface):
         FloatTypeFactory(),
         BoolTypeFactory(),
         DateTimeTypeFactory(),
+        StringTypeFactory(),
     ]
 
     @property
@@ -83,19 +113,6 @@ def typecode(self):
 
         return self.__typecode
 
-    @property
-    def format_str(self):
-        if self.typecode == Typecode.INT:
-            return "d"
-
-        if self.typecode == Typecode.FLOAT:
-            if is_nan(self.decimal_places):
-                return "f"
-
-            return ".%df" % (self.decimal_places)
-
-        return "s"
-
     @property
     def data(self):
         """
@@ -134,9 +151,10 @@ def __init__(
             none_value=None, inf_value=float("inf"), nan_value=float("nan"),
             bool_converter=default_bool_converter,
             datetime_converter=default_datetime_converter,
+            datetime_format_str="%Y-%m-%dT%H:%M:%S%z",
             is_convert=True,
             replace_tabs_with_spaces=True, tab_length=2):
-        super(DataProperty, self).__init__()
+        super(DataProperty, self).__init__(datetime_format_str)
 
         self.__set_data(data, none_value, inf_value, nan_value, is_convert)
         self.__convert_data(bool_converter, datetime_converter)
@@ -154,8 +172,16 @@ def __init__(
         self.__str_len = self.__get_str_len()
 
     def __repr__(self):
-        return ", ".join([
-            ("data=%" + self.format_str) % (self.data),
+        element_list = []
+
+        if self.typecode == Typecode.DATETIME:
+            element_list.append(
+                "data={:s}".format(str(self.data)))
+        else:
+            element_list.append(
+                ("data={:" + self.format_str + "}").format(self.data))
+
+        element_list.extend([
             "typename=" + Typecode.get_typename(self.typecode),
             "align=" + str(self.align),
             "str_len=" + str(self.str_len),
@@ -164,6 +190,8 @@ def __repr__(self):
             "additional_format_len=" + str(self.additional_format_len),
         ])
 
+        return ", ".join(element_list)
+
     def __get_additional_format_len(self):
         if not FloatTypeChecker(self.data).is_type():
             return 0
@@ -194,6 +222,10 @@ def __get_str_len(self):
         if self.typecode == Typecode.FLOAT:
             return self.__get_base_float_len() + self.additional_format_len
 
+        if self.typecode == Typecode.DATETIME:
+            full_format_str = "{:" + self.format_str + "}"
+            return len(full_format_str.format(self.data))
+
         return get_text_len(self.data)
 
     def __set_data(
@@ -222,8 +254,8 @@ def __set_data(
 
             return
 
-        self.__typecode = Typecode.STRING
-        self.__data = str(data)
+        raise TypeConversionError(
+            "failed to convert: " + Typecode.get_typename(self.__typecode))
 
     def __convert_data(self, bool_converter, datetime_converter):
         if self.typecode == Typecode.BOOL:
@@ -241,7 +273,7 @@ def __replace_tabs(self, replace_tabs_with_spaces, tab_length):
             pass
 
 
-class ColumnDataProperty(DataPeropertyInterface):
+class ColumnDataProperty(DataPeropertyBase):
     __slots__ = (
         "__typecode_bitmap",
         "__str_len",
@@ -251,6 +283,17 @@ class ColumnDataProperty(DataPeropertyInterface):
         "__data_prop_list",
     )
 
+    __FACTORY_TABLE = {
+        Typecode.NONE: NoneTypeFactory(),
+        Typecode.STRING: StringTypeFactory(),
+        Typecode.INT: IntegerTypeFactory(),
+        Typecode.INFINITY: InfinityTypeFactory(),
+        Typecode.NAN: NanTypeFactory(),
+        Typecode.FLOAT: FloatTypeFactory(),
+        Typecode.BOOL: BoolTypeFactory(),
+        Typecode.DATETIME: DateTimeTypeFactory(),
+    }
+
     @property
     def align(self):
         return align_getter.get_align_from_typecode(self.typecode)
@@ -304,7 +347,16 @@ def minmax_decimal_places(self):
     def minmax_additional_format_len(self):
         return self.__minmax_additional_format_len
 
-    def __init__(self, min_padding_len=0):
+    @property
+    def type_factory(self):
+        return self.__FACTORY_TABLE.get(self.typecode)
+
+    def __init__(
+            self,
+            min_padding_len=0,
+            datetime_format_str="%Y-%m-%dT%H:%M:%S%z"):
+        super(ColumnDataProperty, self).__init__(datetime_format_str)
+
         self.__typecode_bitmap = Typecode.NONE
         self.__str_len = min_padding_len
         self.__minmax_integer_digits = MinMaxContainer()

dataproperty/_factory.py

@@ -10,11 +10,13 @@
 import six
 
 from .converter import NopConverterCreator
+from .converter import StringConverterCreator
 from .converter import IntegerConverterCreator
 from .converter import FloatConverterCreator
 from .converter import BoolConverterCreator
 from .converter import DateTimeConverterCreator
 from ._type_checker_creator import NoneTypeCheckerCreator
+from ._type_checker_creator import StringTypeCheckerCreator
 from ._type_checker_creator import IntegerTypeCheckerCreator
 from ._type_checker_creator import FloatTypeCheckerCreator
 from ._type_checker_creator import BoolTypeCheckerCreator
@@ -49,6 +51,17 @@ def value_converter_factory(self):
         return NopConverterCreator()
 
 
+class StringTypeFactory(TypeConverterFactoryInterface):
+
+    @property
+    def type_checker_factory(self):
+        return StringTypeCheckerCreator()
+
+    @property
+    def value_converter_factory(self):
+        return StringConverterCreator()
+
+
 class IntegerTypeFactory(TypeConverterFactoryInterface):
 
     @property

dataproperty/_interface.py

@@ -28,16 +28,3 @@ def decimal_places(self):   # pragma: no cover
     @abc.abstractproperty
     def typecode(self):   # pragma: no cover
         pass
-
-    @property
-    def format_str(self):
-        if self.typecode == Typecode.INT:
-            return "d"
-
-        if self.typecode == Typecode.FLOAT:
-            if is_nan(self.decimal_places):
-                return "f"
-
-            return ".%df" % (self.decimal_places)
-
-        return "s"

dataproperty/_property_extractor.py

@@ -24,6 +24,7 @@ def __init__(self):
         self.nan_value = float("nan")
         self.bool_converter = default_bool_converter
         self.datetime_converter = default_datetime_converter
+        self.datetime_format_str = "%Y-%m-%dT%H:%M:%S%z"
         self.is_convert = True
 
     def extract_data_property_matrix(self):
@@ -39,7 +40,8 @@ def extract_column_property_list(self):
 
         for col_idx, col_prop_list in enumerate(zip(*data_prop_matrix)):
             column_prop = ColumnDataProperty(
-                min_padding_len=self.min_padding_len)
+                min_padding_len=self.min_padding_len,
+                datetime_format_str=self.datetime_format_str)
 
             if is_not_empty_list_or_tuple(header_prop_list):
                 header_prop = header_prop_list[col_idx]
@@ -64,6 +66,7 @@ def __extract_data_property_list(self, data_list):
                 nan_value=self.nan_value,
                 bool_converter=self.bool_converter,
                 datetime_converter=self.datetime_converter,
+                datetime_format_str=self.datetime_format_str,
                 is_convert=self.is_convert)
             for data in data_list
         ]

dataproperty/_type_checker.py

@@ -11,6 +11,7 @@
 import six
 
 from .converter import NopConverterCreator
+from .converter import StringConverterCreator
 from .converter import IntegerConverterCreator
 from .converter import FloatConverterCreator
 from .converter import BoolConverterCreator
@@ -95,6 +96,23 @@ def _is_valid_after_convert(self):
         return self._value is None
 
 
+class StringTypeChecker(TypeChecker):
+
+    @property
+    def typecode(self):
+        return Typecode.STRING
+
+    @property
+    def _converter_creator(self):
+        return StringConverterCreator()
+
+    def _is_instance(self):
+        return isinstance(self._value, six.string_types)
+
+    def _is_valid_after_convert(self):
+        return isinstance(self._converted_value, six.string_types)
+
+
 class IntegerTypeChecker(TypeChecker):
 
     @property

dataproperty/_type_checker_creator.py

@@ -10,6 +10,7 @@
 import six
 
 from ._type_checker import NoneTypeChecker
+from ._type_checker import StringTypeChecker
 from ._type_checker import IntegerTypeChecker
 from ._type_checker import FloatTypeChecker
 from ._type_checker import BoolTypeChecker
@@ -32,6 +33,12 @@ def create(self, value, is_convert):
         return NoneTypeChecker(value, is_convert)
 
 
+class StringTypeCheckerCreator(TypeCheckerCreatorInterface):
+
+    def create(self, value, is_convert):
+        return StringTypeChecker(value, is_convert)
+
+
 class IntegerTypeCheckerCreator(TypeCheckerCreatorInterface):
 
     def create(self, value, is_convert):

dataproperty/converter/__init__.py

@@ -7,6 +7,7 @@
 from __future__ import absolute_import
 
 from ._creator import NopConverterCreator
+from ._creator import StringConverterCreator
 from ._creator import IntegerConverterCreator
 from ._creator import FloatConverterCreator
 from ._creator import BoolConverterCreator

dataproperty/converter/_core.py

@@ -37,13 +37,19 @@ def convert(self):
         return self._value
 
 
+class StringConverter(ValueConverter):
+
+    def convert(self):
+        return str(self._value)
+
+
 class IntegerConverter(ValueConverter):
 
     def convert(self):
         try:
             return int(self._value)
         except (TypeError, ValueError, OverflowError):
-            raise TypeConversionError
+            raise TypeConversionError("failed to convert: " + str(self._value))
 
 
 class FloatConverter(ValueConverter):
@@ -57,7 +63,7 @@ def convert(self):
         try:
             return decimal.Decimal(self._value)
         except (TypeError, ValueError, decimal.InvalidOperation):
-            raise TypeConversionError
+            raise TypeConversionError("failed to convert: " + str(self._value))
 
 
 class BoolConverter(ValueConverter):
@@ -68,7 +74,7 @@ def convert(self):
         try:
             return strict_strtobool(self._value)
         except ValueError:
-            raise TypeConversionError
+            raise TypeConversionError("failed to convert: " + str(self._value))
 
 
 class DateTimeConverter(ValueConverter):

dataproperty/converter/_creator.py

@@ -10,6 +10,7 @@
 import six
 
 from ._core import NopConverter
+from ._core import StringConverter
 from ._core import IntegerConverter
 from ._core import FloatConverter
 from ._core import BoolConverter
@@ -30,6 +31,12 @@ def create(self, value):
         return NopConverter(value)
 
 
+class StringConverterCreator(ValueConverterCreatorInterface):
+
+    def create(self, value):
+        return StringConverter(value)
+
+
 class IntegerConverterCreator(ValueConverterCreatorInterface):
 
     def create(self, value):