Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/10.post_attention_layernorm.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5649f5ec224b072caa96b4353b600a32334caac618d611732ccbb39bd556fa0
+size 9372

ckpts/universal/global_step80/zero/10.post_attention_layernorm.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:102e75ca3b034eb5fcd258cc7be038424904f27d188657b8e8f51469f21e93e3
+size 9293

ckpts/universal/global_step80/zero/15.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0b7c08411b198088ba2b3fbd40941b698af85a8142f6b5b5374a8186e6da8ef4
+size 33555612

ckpts/universal/global_step80/zero/15.mlp.dense_h_to_4h_swiglu.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84b0cb47ef3d2049bfc3499262cf936094f60200c074198af02f97a14833c94d
+size 33555627

ckpts/universal/global_step80/zero/16.mlp.dense_h_to_4h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5148dc0e29860bd8e567f179212dfdd2bb5c3ad18cda6686c5226b33cca6d92f
+size 33555612

venv/lib/python3.10/site-packages/typepy/checker/__init__.py

@@ -0,0 +1,35 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._bool import BoolTypeChecker
+from ._bytes import BytesTypeChecker
+from ._datetime import DateTimeTypeChecker
+from ._dictionary import DictionaryTypeChecker
+from ._infinity import InfinityTypeChecker
+from ._integer import IntegerTypeChecker
+from ._interface import TypeCheckerInterface
+from ._ipaddress import IpAddressTypeChecker
+from ._list import ListTypeChecker
+from ._nan import NanTypeChecker
+from ._none import NoneTypeChecker
+from ._realnumber import RealNumberTypeChecker
+from ._string import NullStringTypeChecker, StringTypeChecker
+
+
+__all__ = (
+    "BoolTypeChecker",
+    "BytesTypeChecker",
+    "DateTimeTypeChecker",
+    "DictionaryTypeChecker",
+    "InfinityTypeChecker",
+    "IntegerTypeChecker",
+    "IpAddressTypeChecker",
+    "ListTypeChecker",
+    "NanTypeChecker",
+    "NoneTypeChecker",
+    "NullStringTypeChecker",
+    "RealNumberTypeChecker",
+    "StringTypeChecker",
+    "TypeCheckerInterface",
+)

venv/lib/python3.10/site-packages/typepy/checker/_bool.py

@@ -0,0 +1,41 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from .._const import StrictLevel
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+from ._common import isstring
+
+
+class BoolTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return isinstance(self._value, bool)
+
+    def is_valid_after_convert(self, converted_value):
+        return isinstance(converted_value, bool)
+
+
+class BoolTypeCheckerStrictLevel1(BoolTypeCheckerStrictLevel0):
+    def is_exclude_instance(self):
+        from ..type._integer import Integer
+
+        return Integer(self._value, strict_level=StrictLevel.MAX).is_type()
+
+
+class BoolTypeCheckerStrictLevel2(BoolTypeCheckerStrictLevel1):
+    def is_exclude_instance(self):
+        return super().is_exclude_instance() or isstring(self._value)
+
+
+_factory = CheckerFactory(
+    checker_mapping={
+        0: BoolTypeCheckerStrictLevel0,
+        1: BoolTypeCheckerStrictLevel1,
+        2: BoolTypeCheckerStrictLevel2,
+    }
+)
+
+
+class BoolTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_bytes.py

@@ -0,0 +1,21 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+
+
+class BytesTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return isinstance(self._value, bytes)
+
+    def is_valid_after_convert(self, converted_value):
+        return isinstance(converted_value, bytes)
+
+
+_factory = CheckerFactory(checker_mapping={0: BytesTypeCheckerStrictLevel0})
+
+
+class BytesTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_checker.py

@@ -0,0 +1,90 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import abc
+
+from ._interface import TypeCheckerInterface
+
+
+class CheckerFactory:
+    __slots__ = ("__min_strict_level", "__max_strict_level", "__checker_mapping")
+
+    @property
+    def min_strict_level(self):
+        return self.__min_strict_level
+
+    @property
+    def max_strict_level(self):
+        return self.__max_strict_level
+
+    def __init__(self, checker_mapping):
+        self.__checker_mapping = checker_mapping
+
+        self.__min_strict_level = min(checker_mapping)
+        self.__max_strict_level = max(checker_mapping)
+        self.__checker_mapping[None] = self.__max_strict_level
+
+    def get_checker_class(self, strict_level=None):
+        checker_class = self.__checker_mapping.get(strict_level)
+        if checker_class:
+            return checker_class
+        if strict_level < self.min_strict_level:
+            return self.__checker_mapping[self.min_strict_level]
+        if strict_level > self.max_strict_level:
+            return self.__checker_mapping[self.max_strict_level]
+
+        raise ValueError(f"unexpected strict level: {strict_level}")
+
+
+class TypeCheckerBase(TypeCheckerInterface):
+    __slots__ = ("_value",)
+
+    def __init__(self, value):
+        self._value = value
+
+    @abc.abstractmethod
+    def is_instance(self):
+        pass
+
+    def is_type(self) -> bool:
+        return self.is_instance() and not self.is_exclude_instance()
+
+    def validate(self) -> None:
+        """
+        :raises TypeError:
+            If the value is not matched the type to be expected.
+        """
+
+        if self.is_type():
+            return
+
+        raise TypeError(f"invalid value type: actual={type(self._value)}")
+
+    def is_exclude_instance(self):
+        return False
+
+    def is_valid_after_convert(self, converted_value):
+        return True
+
+
+class TypeCheckerDelegator(TypeCheckerInterface):
+    __slots__ = ("__checker",)
+
+    def __init__(self, value, checker_factory, strict_level):
+        self.__checker = checker_factory.get_checker_class(strict_level)(value)
+
+    def is_type(self) -> bool:
+        return self.__checker.is_type()
+
+    def is_valid_after_convert(self, value):
+        return self.__checker.is_valid_after_convert(value)
+
+    def is_instance(self):
+        return self.__checker.is_instance()
+
+    def is_exclude_instance(self):
+        return self.__checker.is_exclude_instance()
+
+    def validate(self) -> None:
+        self.__checker.validate()

venv/lib/python3.10/site-packages/typepy/checker/_common.py

@@ -0,0 +1,28 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import decimal
+import math
+
+
+def isstring(value):
+    return isinstance(value, (str,) + (str, bytes))
+
+
+def isinf(value):
+    try:
+        return decimal.Decimal(value).is_infinite()
+    except OverflowError:
+        return True
+    except TypeError:
+        return False
+    except (ValueError, decimal.InvalidOperation):
+        return False
+
+
+def isnan(value):
+    try:
+        return math.isnan(value)
+    except (TypeError, OverflowError):
+        return False

venv/lib/python3.10/site-packages/typepy/checker/_datetime.py

@@ -0,0 +1,40 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from datetime import date, datetime
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+from ._common import isstring
+
+
+class DateTimeTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return isinstance(self._value, (date, datetime))
+
+
+class DateTimeTypeCheckerStrictLevel1(DateTimeTypeCheckerStrictLevel0):
+    def is_exclude_instance(self):
+        from ..type._integer import Integer
+
+        # exclude timestamp
+        return Integer(self._value, strict_level=1).is_type()
+
+
+class DateTimeTypeCheckerStrictLevel2(DateTimeTypeCheckerStrictLevel1):
+    def is_exclude_instance(self):
+        return isstring(self._value) or super().is_exclude_instance()
+
+
+_factory = CheckerFactory(
+    checker_mapping={
+        0: DateTimeTypeCheckerStrictLevel0,
+        1: DateTimeTypeCheckerStrictLevel1,
+        2: DateTimeTypeCheckerStrictLevel2,
+    }
+)
+
+
+class DateTimeTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_dictionary.py

@@ -0,0 +1,28 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+
+
+class DictionaryTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return isinstance(self._value, dict)
+
+    def is_valid_after_convert(self, converted_value):
+        return isinstance(converted_value, dict) and converted_value
+
+
+class DictionaryTypeCheckerStrictLevel1(DictionaryTypeCheckerStrictLevel0):
+    def is_exclude_instance(self):
+        return not isinstance(self._value, dict)
+
+
+_factory = CheckerFactory(
+    checker_mapping={0: DictionaryTypeCheckerStrictLevel0, 1: DictionaryTypeCheckerStrictLevel1}
+)
+
+
+class DictionaryTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_infinity.py

@@ -0,0 +1,32 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+from ._common import isinf, isstring
+
+
+class InfinityCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return isinf(self._value)
+
+    def is_valid_after_convert(self, converted_value):
+        try:
+            return converted_value.is_infinite()
+        except AttributeError:
+            return False
+
+
+class InfinityCheckerStrictLevel1(InfinityCheckerStrictLevel0):
+    def is_exclude_instance(self):
+        return isstring(self._value)
+
+
+_factory = CheckerFactory(
+    checker_mapping={0: InfinityCheckerStrictLevel0, 1: InfinityCheckerStrictLevel1}
+)
+
+
+class InfinityTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_integer.py

@@ -0,0 +1,72 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import re
+from decimal import Decimal
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+from ._common import isinf, isnan
+
+
+RE_SCIENTIFIC_NOTATION = re.compile(r"^-?\d+(?:\.\d*)?[eE][+\-]?\d{3,}$")
+
+
+class IntegerTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        if isinstance(self._value, int):
+            return not isinstance(self._value, bool)
+
+        if isinstance(self._value, (float, Decimal)):
+            return True
+
+        return False
+
+    def is_exclude_instance(self):
+        return isnan(self._value) or isinf(self._value)
+
+
+class IntegerTypeCheckerStrictLevel1(IntegerTypeCheckerStrictLevel0):
+    def is_instance(self):
+        if not super().is_instance():
+            return False
+
+        if isinstance(self._value, (float, Decimal)):
+            if float(self._value).is_integer():
+                return True
+
+        try:
+            return self._value.is_integer()
+        except AttributeError:
+            pass
+
+        return False
+
+    def is_exclude_instance(self):
+        from ..type._realnumber import RealNumber
+
+        return (
+            super().is_exclude_instance()
+            or isinstance(self._value, bool)
+            or RealNumber(self._value, strict_level=1).is_type()
+            or (isinstance(self._value, str) and RE_SCIENTIFIC_NOTATION.search(self._value))
+        )
+
+
+class IntegerTypeCheckerStrictLevel2(IntegerTypeCheckerStrictLevel1):
+    def is_exclude_instance(self):
+        return isinstance(self._value, (str,) + (bool, float, Decimal))
+
+
+_factory = CheckerFactory(
+    checker_mapping={
+        0: IntegerTypeCheckerStrictLevel0,
+        1: IntegerTypeCheckerStrictLevel1,
+        2: IntegerTypeCheckerStrictLevel2,
+    }
+)
+
+
+class IntegerTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_interface.py

@@ -0,0 +1,15 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import abc
+
+
+class TypeCheckerInterface(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def is_type(self) -> bool:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def validate(self) -> None:  # pragma: no cover
+        pass

venv/lib/python3.10/site-packages/typepy/checker/_ipaddress.py

@@ -0,0 +1,35 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+from ._common import isstring
+
+
+class IpAddressTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return self._is_ipaddress(self._value)
+
+    def is_valid_after_convert(self, converted_value):
+        return self._is_ipaddress(converted_value)
+
+    @staticmethod
+    def _is_ipaddress(value):
+        import ipaddress
+
+        return isinstance(value, (ipaddress.IPv4Address, ipaddress.IPv6Address))
+
+
+class IpAddressTypeCheckerStrictLevel1(IpAddressTypeCheckerStrictLevel0):
+    def is_exclude_instance(self):
+        return isstring(self._value) or super().is_exclude_instance()
+
+
+_factory = CheckerFactory(
+    checker_mapping={0: IpAddressTypeCheckerStrictLevel0, 1: IpAddressTypeCheckerStrictLevel1}
+)
+
+
+class IpAddressTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_list.py

@@ -0,0 +1,32 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+from ._common import isstring
+
+
+class ListTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return isinstance(self._value, list)
+
+    def is_valid_after_convert(self, converted_value):
+        return isinstance(converted_value, list) and converted_value
+
+    def is_exclude_instance(self):
+        return isstring(self._value)
+
+
+class ListTypeCheckerStrictLevel1(ListTypeCheckerStrictLevel0):
+    def is_exclude_instance(self):
+        return super().is_exclude_instance() or not isinstance(self._value, list)
+
+
+_factory = CheckerFactory(
+    checker_mapping={0: ListTypeCheckerStrictLevel0, 1: ListTypeCheckerStrictLevel1}
+)
+
+
+class ListTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_nan.py

@@ -0,0 +1,29 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+from ._common import isnan, isstring
+
+
+class NanTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return isnan(self._value)
+
+    def is_valid_after_convert(self, converted_value):
+        return isnan(converted_value)
+
+
+class NanTypeCheckerStrictLevel1(NanTypeCheckerStrictLevel0):
+    def is_exclude_instance(self):
+        return isstring(self._value)
+
+
+_factory = CheckerFactory(
+    checker_mapping={0: NanTypeCheckerStrictLevel0, 1: NanTypeCheckerStrictLevel1}
+)
+
+
+class NanTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_none.py

@@ -0,0 +1,21 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+
+
+class NoneTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return self._value is None
+
+    def is_valid_after_convert(self, converted_value):
+        return self._value is None
+
+
+_factory = CheckerFactory(checker_mapping={0: NoneTypeCheckerStrictLevel0})
+
+
+class NoneTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_realnumber.py

@@ -0,0 +1,61 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import re
+from decimal import Decimal
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+from ._common import isinf, isnan, isstring
+
+
+RE_E = re.compile("[eE]")
+RE_SCIENTIFIC_NOTATION = re.compile(r"^-?\d+(?:\.\d*)?[eE][+\-]?\d{,2}$")
+
+
+class RealNumberTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return isinstance(self._value, (float, Decimal))
+
+    def is_exclude_instance(self):
+        return isinstance(self._value, bool) or isnan(self._value) or isinf(self._value)
+
+    def is_valid_after_convert(self, converted_value):
+        return not isinf(converted_value) and not isnan(converted_value)
+
+
+class RealNumberTypeCheckerStrictLevel1(RealNumberTypeCheckerStrictLevel0):
+    def is_instance(self):
+        return super().is_instance() and not float(self._value).is_integer()
+
+    def is_exclude_instance(self):
+        if (
+            isinstance(self._value, str)
+            and RE_E.search(self._value)
+            and RE_SCIENTIFIC_NOTATION.search(self._value) is None
+        ):
+            return True
+
+        return isinstance(self._value, int) or super().is_exclude_instance()
+
+    def is_valid_after_convert(self, converted_value):
+        return not float(converted_value).is_integer()
+
+
+class RealNumberTypeCheckerStrictLevel2(RealNumberTypeCheckerStrictLevel1):
+    def is_exclude_instance(self):
+        return super().is_exclude_instance() or isstring(self._value)
+
+
+_factory = CheckerFactory(
+    checker_mapping={
+        0: RealNumberTypeCheckerStrictLevel0,
+        1: RealNumberTypeCheckerStrictLevel1,
+        2: RealNumberTypeCheckerStrictLevel2,
+    }
+)
+
+
+class RealNumberTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_factory, strict_level=strict_level)

venv/lib/python3.10/site-packages/typepy/checker/_string.py

@@ -0,0 +1,74 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._checker import CheckerFactory, TypeCheckerBase, TypeCheckerDelegator
+from ._common import isstring
+
+
+class StringTypeCheckerStrictLevel0(TypeCheckerBase):
+    def is_instance(self):
+        return isstring(self._value)
+
+    def is_valid_after_convert(self, converted_value):
+        return isstring(converted_value)
+
+    def _is_null_string(self, value):
+        try:
+            value = value.strip()
+        except AttributeError:
+            return False
+
+        return len(value) == 0
+
+
+class StringTypeCheckerStrictLevel1(StringTypeCheckerStrictLevel0):
+    def is_exclude_instance(self):
+        return not isstring(self._value)
+
+
+class StringTypeCheckerStrictLevel2(StringTypeCheckerStrictLevel1):
+    def is_exclude_instance(self):
+        if super().is_exclude_instance():
+            return True
+
+        return self._is_null_string(self._value)
+
+
+_string_factory = CheckerFactory(
+    checker_mapping={
+        0: StringTypeCheckerStrictLevel0,
+        1: StringTypeCheckerStrictLevel1,
+        2: StringTypeCheckerStrictLevel2,
+    }
+)
+
+
+class StringTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(value=value, checker_factory=_string_factory, strict_level=strict_level)
+
+
+class NullStringTypeCheckerStrictLevel0(StringTypeCheckerStrictLevel0):
+    def is_instance(self):
+        return self._value is None
+
+    def is_valid_after_convert(self, converted_value):
+        return self._is_null_string(converted_value)
+
+
+class NullStringTypeCheckerStrictLevel1(NullStringTypeCheckerStrictLevel0):
+    def is_instance(self):
+        return False
+
+
+_null_string_factory = CheckerFactory(
+    checker_mapping={0: NullStringTypeCheckerStrictLevel0, 1: NullStringTypeCheckerStrictLevel1}
+)
+
+
+class NullStringTypeChecker(TypeCheckerDelegator):
+    def __init__(self, value, strict_level):
+        super().__init__(
+            value=value, checker_factory=_null_string_factory, strict_level=strict_level
+        )

venv/lib/python3.10/site-packages/typepy/converter/__init__.py

@@ -0,0 +1,31 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from ._bool import BoolConverter
+from ._bytes import BytesConverter
+from ._datetime import DateTimeConverter
+from ._dictionary import DictionaryConverter
+from ._integer import IntegerConverter
+from ._interface import ValueConverterInterface
+from ._ipaddress import IpAddressConverter
+from ._list import ListConverter
+from ._nop import NopConverter
+from ._realnumber import FloatConverter
+from ._string import NullStringConverter, StringConverter
+
+
+__all__ = (
+    "BoolConverter",
+    "BytesConverter",
+    "DateTimeConverter",
+    "DictionaryConverter",
+    "FloatConverter",
+    "IntegerConverter",
+    "IpAddressConverter",
+    "ListConverter",
+    "NopConverter",
+    "NullStringConverter",
+    "StringConverter",
+    "ValueConverterInterface",
+)