updated to 1.0.7

build/lib/s1zlibs/jsoner/__init__.py

-from __future__ import absolute_import
-try:
-    import simplejson as json
-except ImportError as e:
-    import json
-
-from .fields.base_field import BaseField
-from .functions import jsonize_str
-from .functions import pythonize_str
-from .decorators import with_metaclass
-
-
-TAG = "Serializable"
-
-_field_name = "_jsoner_data"
-
-
-class MetaSerializable(type):
-
-    def __new__(cls, name, bases, attrs):
-        jsoner_field = attrs.pop(_field_name, {})
-        new_cls = super(MetaSerializable, cls).__new__(cls, name, bases, attrs)
-
-        for base in bases:
-            if hasattr(base, _field_name):
-                jsoner_field.update(getattr(base, _field_name, {}))
-
-        for k, v in attrs.items():
-            if isinstance(v, BaseField):
-                # Here's the place where the magic comes!
-                jsoner_field[k] = v
-                setattr(new_cls, k, None)
-
-        setattr(new_cls, _field_name, jsoner_field)
-        return new_cls
-
-    def __call__(cls, *args, **kwargs):
-        return type.__call__(cls, *args, **kwargs)
-
-
-@with_metaclass(MetaSerializable)
-class Serializable(object):
-
-    def loads(self, data):
-        # type: () -> self
-        loaded = json.loads(data)
-        if not isinstance(loaded, dict):
-            raise AttributeError("data is not dict instance: '{}'".format(
-                type(data).__name__
-            ))
-        for field_name, field in getattr(self, _field_name, {}).items():
-            if isinstance(field, BaseField):
-                j_field_name = pythonize_str(field_name) if field.jsonize else \
-                               field_name
-                j_value = loaded.get(j_field_name, None)
-                loaded_value = field.loads(j_value)
-                setattr(self, field_name, loaded_value)
-        return self
-
-    def dumps(self):
-        # type: () -> self
-        dumped = dict()
-        for field_name, field in getattr(self, _field_name, {}).items():
-            if isinstance(field, BaseField):
-                value = getattr(self, field_name, None)
-                j_field_name = jsonize_str(field_name) if field.jsonize else \
-                               field_name
-                j_value = field.dumps(value)
-                dumped[j_field_name] = j_value
-        return json.dumps(dumped)

build/lib/s1zlibs/jsoner/decorators.py

@@ -2,10 +2,11 @@ from __future__ import absolute_import
 from __future__ import unicode_literals
 
 
-def with_metaclass(mcls):
+def with_metaclass(meta):
     def decorator(cls):
-        body = vars(cls).copy()
-        body.pop('__dict__', None)
-        body.pop('__weakref__', None)
-        return mcls(cls.__name__, cls.__bases__, body)
+        # TODO(s1z): Please check this code!
+        attrs = vars(cls).copy()
+        attrs.pop('__dict__', None)
+        attrs.pop('__weakref__', None)
+        return meta(cls.__name__, cls.__bases__, attrs)
     return decorator

build/lib/s1zlibs/jsoner/exceptions/__init__.py

+class JsonerException(Exception):
+    pass
+
+
+class TypeMismatch(JsonerException):
+    pass
+
+
+class FieldRequired(JsonerException):
+    pass

build/lib/s1zlibs/jsoner/fields/base_field.py

 from __future__ import absolute_import
 from __future__ import unicode_literals
-from ..serializers.simple_serializer import SimpleSerializer
+from sys import version_info
 
 
-TAG = "BaseField"
+if version_info[0] == 3:
+    unicode = str
+
+
+TAG = __name__
 
 
 class BaseField(object):
 
-    serializer = None
-    null = None
-    jsonize = None
-
-    def __init__(self, value_type, serializer=SimpleSerializer, null=True,
-                 jsonize=True):
-        """
-        :param value_type: type of the value we serialize
-        :type  value_type: any
-        :param serializer: Serializer class
-        :type  serializer: any
-        :param null: Do we need to send null if None is set
-        :type  null: bool
-        :param jsonize: Should we convert "test_name" to "testName" and back
-        :type  jsonize: bool
-        """
-        self.serializer = serializer(value_type)
-        self.null = null
-        self.jsonize = jsonize
-
-    def check_null(self, value):
-        if value is None and self.null is not True:
-            raise AttributeError("Value has to be not null: {}".format(value))
-        return value
-
-    def loads(self, value):
-        return self.serializer.loads(value)
-
-    def dumps(self, value):
-        self.check_null(value)
-        return self.serializer.dumps(value)
+    _field_name = None    # type: unicode
+    _value_is_set = None  # type: bool
+    _value = None         # type: any
+
+    def get_value(self):
+        return self._value
+
+    def set_value(self, value):
+        self._value_is_set = True
+        self._value = value
+
+    def del_value(self):
+        self._value_is_set = False
+        self._value = None
+
+    def is_value_set(self):
+        return self._value_is_set is True
+
+    def get_field_name(self):
+        return self._field_name
+
+    def loads(self, data):
+        # type: (any) -> any
+        raise NotImplementedError("IMPL ME")
+
+    def dumps(self, data):
+        # type: (any) -> any
+        raise NotImplementedError("IMPL ME")

build/lib/s1zlibs/jsoner/fields/simple_field.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from sys import version_info
+from .base_field import BaseField
+from ..serializers.base_serializer import BaseSerializer
+from ..serializers.simple_serializer import SimpleSerializer
+from ..exceptions import FieldRequired
+
+if version_info[0] == 3:
+    unicode = str
+
+
+TAG = __name__
+
+
+class SimpleField(BaseField):
+
+    _field_name = None  # type: unicode
+    _field_type = None  # type: any
+    _serializer = None  # type: BaseSerializer
+
+    def __init__(self, field_type, field_name=None,
+                 serializer=SimpleSerializer):
+        """
+        :param field_type: The type of field's value
+        :param field_name: The name of the field
+        :param serializer: The serializer of the field value
+        :param null: Set's whether value can be null or not
+        """
+        self._field_type = field_type
+        self._field_name = field_name
+        self._serializer = serializer(field_type)
+
+    def loads(self, value):
+        return self._serializer.loads(value)
+
+    def dumps(self, value):
+        return self._serializer.dumps(value)

build/lib/s1zlibs/jsoner/functions.py

@@ -5,33 +5,33 @@ from __future__ import unicode_literals
 def pythonize_str(data):
     # Converts name to a python style names:
     # simpleTestValue -> simple_test_value
-    name_len = len(data)
     new_data = ""
-    for i in range(name_len):
-        c = data[i]
-        if c.isupper():
-            new_data += "_" + c.lower()
+    for i in range(len(data)):
+        curr_chr = data[i]
+        if curr_chr.isupper():
+            new_data += "_" + curr_chr.lower()
         else:
-            new_data += c
+            new_data += curr_chr
     return new_data
 
 
 def jsonize_str(data):
     # Converts data to a json style names:
     # simple_test_value -> simpleTestValue
-    if data.find("_") == -1:
-        return data
-    name_len = len(data)
-    new_data = ""
-    for i in range(name_len):
-        c = data[i]
-        if c == "_":
+    new_data = ''
+    for i in range(len(data)):
+        curr_chr = data[i]
+        if curr_chr == '_':
             continue
-        elif i == 0 and c.isalpha():
-            new_data += c
-        elif c.isalpha():
-            if data[i - 1] == "_":
-                new_data += c.upper()
+        elif i == 0:
+            # first char is always lower case! don't care if it isn't alpha.
+            new_data += curr_chr.lower()
+        elif curr_chr.isalpha() and data[i - 1] == '_':
+            # If alpha and prev chr is '_' we push it in upper case.
+            new_data += curr_chr.upper()
+        elif not curr_chr.isalpha() and data[i - 1] == '_':
+            # If not alpha and we copy prev and curr not changed.
+            new_data += "_" + curr_chr
         else:
-                new_data += c
+            new_data += curr_chr
     return new_data

build/lib/s1zlibs/jsoner/models/base_model.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from .decorators import with_metaclass
+from .meta_model import MetaModel
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+
+TAG = __name__
+
+
+@with_metaclass(MetaModel)
+class BaseModel(object):
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def loads(self, data):
+        raise NotImplementedError("IMPL ME")
+
+    def dumps(self):
+        raise NotImplementedError("IMPL ME")
+
+    @classmethod
+    def from_json(cls, data):
+        # type: (unicode) -> any
+        self = cls.__new__(cls)
+        return self.loads(json.loads(data))
+
+    def to_json(self):
+        # type: (any) -> unicode
+        return json.dumps(self.dumps())

build/lib/s1zlibs/jsoner/models/decorators.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+
+
+TAG = __name__
+
+
+def with_metaclass(meta):
+    def decorator(cls):
+        # TODO(s1z): Please check this code!
+        attrs = vars(cls).copy()
+        attrs.pop('__dict__', None)
+        attrs.pop('__weakref__', None)
+        return meta(cls.__name__, cls.__bases__, attrs)
+    return decorator

build/lib/s1zlibs/jsoner/models/functions.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+
+
+def pythonize_str(data):
+    # Converts name to a python style names:
+    # simpleTestValue -> simple_test_value
+    new_data = ""
+    for i in range(len(data)):
+        curr_chr = data[i]
+        if curr_chr.isupper():
+            new_data += "_" + curr_chr.lower()
+        else:
+            new_data += curr_chr
+    return new_data
+
+
+def jsonize_str(data):
+    # Converts data to a json style names:
+    # simple_test_value -> simpleTestValue
+    new_data = ''
+    for i in range(len(data)):
+        curr_chr = data[i]
+        if curr_chr == '_':
+            continue
+        elif i == 0:
+            # first char is always lower case! don't care if it isn't alpha.
+            new_data += curr_chr.lower()
+        elif curr_chr.isalpha() and data[i - 1] == '_':
+            # If alpha and prev chr is '_' we push it in upper case.
+            new_data += curr_chr.upper()
+        elif not curr_chr.isalpha() and data[i - 1] == '_':
+            # If not alpha and we copy prev and curr not changed.
+            new_data += "_" + curr_chr
+        else:
+            new_data += curr_chr
+    return new_data

build/lib/s1zlibs/jsoner/models/list_model.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from .base_model import BaseModel
+
+
+TAG = __name__
+
+
+class ListModel(BaseModel):
+    def loads(self):
+        raise NotImplementedError("IMPL ME")
+
+    def dumps(self):
+        raise NotImplementedError("IMPL ME")

build/lib/s1zlibs/jsoner/models/meta_model.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from ..fields.base_field import BaseField
+
+
+TAG = __name__
+
+
+JSONER_DATA_FIELD = "_jsoner_fields"
+
+
+class MetaModel(type):
+
+    def __new__(cls, name, bases, attrs):
+
+        # Creating a new class jsoner_field
+        jsoner_field_cls = attrs.pop(JSONER_DATA_FIELD, {})
+
+        # Creating a base classes jsoner_field
+        jsoner_field_base = {}
+
+        # Creating the new class
+        new_cls = super(MetaModel, cls).__new__(cls, name, bases, attrs)
+
+        # Copying base blasses jsoner_fields
+        for base in bases:
+            if hasattr(base, JSONER_DATA_FIELD):
+                jsoner_field_base.update(getattr(base, JSONER_DATA_FIELD, {}))
+
+        # Setting the new class jsoner_field
+        for k, v in attrs.items():
+            if isinstance(v, BaseField):
+                # Here's the place where the magic comes!
+                jsoner_field_cls[k] = v
+
+                def get_value(self):
+                    return v.get_value()
+
+                def set_value(self, value):
+                    return v.set_value(value)
+
+                def del_value(self):
+                    return v.del_value()
+
+                setattr(new_cls, k, property(get_value,
+                                             set_value,
+                                             del_value))
+        jsoner_field = dict()
+        jsoner_field.update(jsoner_field_base)
+        jsoner_field.update(jsoner_field_cls)  # overwrites base fields!
+        setattr(new_cls, JSONER_DATA_FIELD, jsoner_field)
+        return new_cls
+
+    def __call__(cls, *args, **kwargs):
+        instance = type.__call__(cls)
+        for name, field in getattr(instance, JSONER_DATA_FIELD, {}).items():
+            if name in kwargs:
+                setattr(instance, name, kwargs.get(name))
+        return type.__call__(cls)

build/lib/s1zlibs/jsoner/models/object_model.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from .meta_model import JSONER_DATA_FIELD
+from .base_model import BaseModel
+from .functions import pythonize_str, jsonize_str
+from ..exceptions import FieldRequired
+
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+
+TAG = __name__
+
+
+class ObjectModel(BaseModel):
+
+    def loads(self, data):
+        # type: (dict) -> any
+        fields = getattr(self, JSONER_DATA_FIELD, {})
+        for field_name, field in fields.items():
+            j_field_name = field.get_field_name() or jsonize_str(field_name)
+            loaded_value = data.get(j_field_name, None)
+            j_field_value = field.loads(loaded_value)
+            setattr(self, field_name, j_field_value)
+        return self
+
+    def dumps(self):
+        # type: () -> dict
+        dumped = dict()
+        instance_fields = getattr(self, JSONER_DATA_FIELD, {})
+        for field_name, field in instance_fields.items():
+            j_field_name = field.get_field_name() or jsonize_str(field_name)
+            if field.is_value_set():
+                dumped_value = getattr(self, field_name, None)
+                j_field_value = field.dumps(dumped_value)
+                dumped[j_field_name] = j_field_value
+        return dumped

build/lib/s1zlibs/jsoner/serializers/base_serializer.py

 from __future__ import absolute_import
 from __future__ import unicode_literals
-from abc import ABCMeta
-from abc import abstractmethod
-from ..decorators import with_metaclass
 
 
-@with_metaclass(ABCMeta)
 class BaseSerializer(object):
 
-    @abstractmethod
     def loads(self, data):
         # type: (bytes) -> BaseSerializer
-        raise NotImplementedError("IMPL ME")
+        pass
 
-    @abstractmethod
     def dumps(self, data):
-        # type: (any) -> bytes
-        raise NotImplementedError("IMPL ME")
+        # type: (any) -> any
+        pass
\ No newline at end of file

build/lib/s1zlibs/jsoner/serializers/simple_serializer.py

 from __future__ import absolute_import
 from __future__ import unicode_literals
-from ...utils.log import Log
-from .base_serializer import BaseSerializer
 from sys import version_info
 
+from .base_serializer import BaseSerializer
+from utils.log import Log
+
 
 TAG = "SimpleSerializer"
 
@@ -65,6 +66,9 @@ class SimpleSerializer(BaseSerializer):
         self.raise_value_error(value, [self.value_type])
 
     def dumps(self, value):
+        if value is None:
+            return value
+
         if not self.value_is_list and not isinstance(value, list):
             self.check_type([value])
             return value

build/lib/s1zlibs/test.py

+#! /usr/bin/env python
+from __future__ import absolute_import
+from __future__ import unicode_literals
+from __future__ import print_function
+from jsoner.models.object_model import ObjectModel
+from jsoner.fields.simple_field import SimpleField
+
+
+class TestObject(ObjectModel):
+    zzz_z = SimpleField(int, 'lol')
+
+
+class Test2Object(TestObject):
+    zzz_a = SimpleField([int])
+
+
+def main():
+    test2 = Test2Object(zzz_z=1, zzz_a=[])
+    test3 = Test2Object.from_json(test2.to_json())
+
+
+if __name__ == "__main__":
+    main()

build/lib/s1zlibs/utils/log.py

@@ -4,30 +4,40 @@ import traceback
 import logging
 
 
+def init_logging(filename=None, level=None):
+    logging_config = {"format": "%(asctime)-23s %(levelname)8s: %(message)s",
+                      "level": level or logging.INFO}
+    if filename is not None:
+        logging_config["filename"] = filename
+    logging.getLogger().handlers = []
+    logging.basicConfig(**logging_config)
+
+
 try:
     import threading
-except ImportError: #pragma: no cover
+except ImportError:  # pragma: no cover
     threading = None
 
 
 if threading:
     _lock = threading.RLock()
-else: #pragma: no cover
+else:  # pragma: no cover
     _lock = None
 
 
-def _acquireLock():
+def _acquire_lock():
     """
     Acquire the module-level lock for serializing access to shared data.
 
-    This should be released with _releaseLock().
+    This should be released with _release_lock().
     """
     if _lock:
         _lock.acquire()
 
-def _releaseLock():
+
+def _release_lock():
     """
-    Release the module-level lock acquired by calling _acquireLock().
+    Release the module-level lock acquired by calling _acquire_lock().
     """
     if _lock:
         _lock.release()
@@ -35,32 +45,26 @@ def _releaseLock():
 
 class Log(object):
 
-    logger = logging.getLogger()
+    LEVEL = logging.DEBUG
+
     handler = logging.StreamHandler()
+    handler.setLevel(LEVEL)
 
-    handler.setLevel(logging.DEBUG)
-    logger.setLevel(logging.DEBUG)
+    logger = logging.getLogger()
+    logger.setLevel(LEVEL)
     logger.addHandler(handler)
 
-    tags = dict()
-
     @staticmethod
-    def get_or_create_tag(tag):
-        # TODO(s1z): Finish this please
-        _acquireLock()
-        try:
-            if tag in Log.tags:
-                return Log.tags[tag]
-        finally:
-            _releaseLock()
+    def get_or_create_logger(tag):
+        return logging.getLogger(tag)
 
     @staticmethod
     def log(level, tag, message, ex):
+        # The tab should be the module.__name__ but not required!
         if ex is not None:
             # exc_type, exc_value, exc_traceback = sys.exc_info()
-            message = "%s\n%s" % (message, traceback.format_exc())
-        msg = "{}::{}".format(tag, message)
-        Log.logger.log(level, msg)
+            message = "%s\nTraceback:\n%s" % (message, traceback.format_exc())
+        logging.getLogger(tag).log(level, message)
 
     @staticmethod
     def v(tag, message, ex=None):

build/lib/s1zlibs/utils/pbkdf2_hmac.py

-from __future__ import absolute_import
 from __future__ import unicode_literals
-from hashlib import new
-
-
-try:
-    range = xrange
-except NameError:
-    buffer = memoryview
+from __future__ import absolute_import
 
 
 try:
     # OpenSSL's PKCS5_PBKDF2_HMAC requires OpenSSL 1.0+ with HMAC and SHA
     from _hashlib import pbkdf2_hmac
 except ImportError:
+    from hashlib import new
     import binascii
     import struct
+    import sys
 
-    _trans_5C = bytes(bytearray([x ^ 0x5C for x in range(256)]))
-    _trans_36 = bytes(bytearray([x ^ 0x36 for x in range(256)]))
+    try:
+        range = xrange
+    except NameError:
+        unicode = str
+
+    _trans_5C = bytearray(x ^ 0x5C for x in range(256))
+    _trans_36 = bytearray(x ^ 0x36 for x in range(256))
+
+    def data_to_bytes(data, encoding="utf-8"):
+        if sys.version_info < (3, 0):
+            return bytes(data)
+        else:
+            return bytes(data, encoding)
 
     def pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None):
         """Password based key derivation function 2 (PKCS #5 v2.0)
@@ -26,18 +32,19 @@ except ImportError:
         as OpenSSL's PKCS5_PBKDF2_HMAC for short passwords and much faster
         for long passwords.
         """
-        if not isinstance(hash_name, str):
+        if not isinstance(hash_name, (str, unicode)):
             raise TypeError(hash_name)
 
         if not isinstance(password, (bytes, bytearray)):
-            raise TypeError("a bytes-like object is required, not '{}'".format(
-                type(password).__name__
-            ))
-
+            error = "a bytes-like object is required, not '{}'".format(
+                password.__class__.__name__
+            )
+            raise TypeError(error)
         if not isinstance(salt, (bytes, bytearray)):
-            raise TypeError("a bytes-like object is required, not '{}'".format(
-                type(salt).__name__
-            ))
+            error = "a bytes-like object is required, not '{}'".format(
+                salt.__class__.__name__
+            )
+            raise TypeError(error)
 
         # Fast inline HMAC implementation
         inner = new(hash_name)
@@ -79,3 +86,7 @@ except ImportError:
             dkey += binascii.unhexlify(hex_format_string % rkey)
 
         return dkey[:dklen]
+
+
+def pbkdf(secret, salt, hash="sha256", iterations=10000, dklen=128):
+    return pbkdf2_hmac(hash, secret, salt, iterations, dklen)

s1zlibs.egg-info/PKG-INFO

 Metadata-Version: 2.1
 Name: s1zlibs
-Version: 1.0.6
+Version: 1.0.7
 Summary: s1zlibs
 Home-page: https://git.s1z.info/skal/s1zlibs
 Author: Barabash Oleksandr

s1zlibs.egg-info/SOURCES.txt

 README.md
 setup.py
 s1zlibs/__init__.py
+s1zlibs/test.py
 s1zlibs.egg-info/PKG-INFO
 s1zlibs.egg-info/SOURCES.txt
 s1zlibs.egg-info/dependency_links.txt
@@ -8,10 +9,17 @@ s1zlibs.egg-info/top_level.txt
 s1zlibs/jsoner/__init__.py
 s1zlibs/jsoner/decorators.py
 s1zlibs/jsoner/functions.py
+s1zlibs/jsoner/exceptions/__init__.py
 s1zlibs/jsoner/fields/__init__.py
 s1zlibs/jsoner/fields/base_field.py
-s1zlibs/jsoner/serializable/__init__.py
-s1zlibs/jsoner/serializable/base_serializable.py
+s1zlibs/jsoner/fields/simple_field.py
+s1zlibs/jsoner/models/__init__.py
+s1zlibs/jsoner/models/base_model.py
+s1zlibs/jsoner/models/decorators.py
+s1zlibs/jsoner/models/functions.py
+s1zlibs/jsoner/models/list_model.py
+s1zlibs/jsoner/models/meta_model.py
+s1zlibs/jsoner/models/object_model.py
 s1zlibs/jsoner/serializers/__init__.py
 s1zlibs/jsoner/serializers/base_serializer.py
 s1zlibs/jsoner/serializers/simple_serializer.py

s1zlibs/jsoner/__init__.py

-from __future__ import absolute_import
-try:
-    import simplejson as json
-except ImportError as e:
-    import json
-
-from .fields.base_field import BaseField
-from .functions import jsonize_str
-from .functions import pythonize_str
-from .decorators import with_metaclass
-
-
-TAG = "Serializable"
-
-_field_name = "_jsoner_data"
-
-
-class MetaSerializable(type):
-
-    def __new__(cls, name, bases, attrs):
-        jsoner_field = attrs.pop(_field_name, {})
-        new_cls = super(MetaSerializable, cls).__new__(cls, name, bases, attrs)
-
-        for base in bases:
-            if hasattr(base, _field_name):
-                jsoner_field.update(getattr(base, _field_name, {}))
-
-        for k, v in attrs.items():
-            if isinstance(v, BaseField):
-                # Here's the place where the magic comes!
-                jsoner_field[k] = v
-                setattr(new_cls, k, None)
-
-        setattr(new_cls, _field_name, jsoner_field)
-        return new_cls
-
-    def __call__(cls, *args, **kwargs):
-        return type.__call__(cls, *args, **kwargs)
-
-
-@with_metaclass(MetaSerializable)
-class Serializable(object):
-
-    def loads(self, data):
-        # type: () -> self
-        loaded = json.loads(data)
-        if not isinstance(loaded, dict):
-            raise AttributeError("data is not dict instance: '{}'".format(
-                type(data).__name__
-            ))
-        for field_name, field in getattr(self, _field_name, {}).items():
-            if isinstance(field, BaseField):
-                j_field_name = pythonize_str(field_name) if field.jsonize else \
-                               field_name
-                j_value = loaded.get(j_field_name, None)
-                loaded_value = field.loads(j_value)
-                setattr(self, field_name, loaded_value)
-        return self
-
-    def dumps(self):
-        # type: () -> self
-        dumped = dict()
-        for field_name, field in getattr(self, _field_name, {}).items():
-            if isinstance(field, BaseField):
-                value = getattr(self, field_name, None)
-                j_field_name = jsonize_str(field_name) if field.jsonize else \
-                               field_name
-                j_value = field.dumps(value)
-                dumped[j_field_name] = j_value
-        return json.dumps(dumped)

s1zlibs/jsoner/decorators.py

@@ -2,10 +2,11 @@ from __future__ import absolute_import
 from __future__ import unicode_literals
 
 
-def with_metaclass(mcls):
+def with_metaclass(meta):
     def decorator(cls):
-        body = vars(cls).copy()
-        body.pop('__dict__', None)
-        body.pop('__weakref__', None)
-        return mcls(cls.__name__, cls.__bases__, body)
+        # TODO(s1z): Please check this code!
+        attrs = vars(cls).copy()
+        attrs.pop('__dict__', None)
+        attrs.pop('__weakref__', None)
+        return meta(cls.__name__, cls.__bases__, attrs)
     return decorator

s1zlibs/jsoner/exceptions/__init__.py

+class JsonerException(Exception):
+    pass
+
+
+class TypeMismatch(JsonerException):
+    pass
+
+
+class FieldRequired(JsonerException):
+    pass

s1zlibs/jsoner/fields/base_field.py

 from __future__ import absolute_import
 from __future__ import unicode_literals
-from ..serializers.simple_serializer import SimpleSerializer
+from sys import version_info
 
 
-TAG = "BaseField"
+if version_info[0] == 3:
+    unicode = str
+
+
+TAG = __name__
 
 
 class BaseField(object):
 
-    serializer = None
-    null = None
-    jsonize = None
-
-    def __init__(self, value_type, serializer=SimpleSerializer, null=True,
-                 jsonize=True):
-        """
-        :param value_type: type of the value we serialize
-        :type  value_type: any
-        :param serializer: Serializer class
-        :type  serializer: any
-        :param null: Do we need to send null if None is set
-        :type  null: bool
-        :param jsonize: Should we convert "test_name" to "testName" and back
-        :type  jsonize: bool
-        """
-        self.serializer = serializer(value_type)
-        self.null = null
-        self.jsonize = jsonize
-
-    def check_null(self, value):
-        if value is None and self.null is not True:
-            raise AttributeError("Value has to be not null: {}".format(value))
-        return value
-
-    def loads(self, value):
-        return self.serializer.loads(value)
-
-    def dumps(self, value):
-        self.check_null(value)
-        return self.serializer.dumps(value)
+    _field_name = None    # type: unicode
+    _value_is_set = None  # type: bool
+    _value = None         # type: any
+
+    def get_value(self):
+        return self._value
+
+    def set_value(self, value):
+        self._value_is_set = True
+        self._value = value
+
+    def del_value(self):
+        self._value_is_set = False
+        self._value = None
+
+    def is_value_set(self):
+        return self._value_is_set is True
+
+    def get_field_name(self):
+        return self._field_name
+
+    def loads(self, data):
+        # type: (any) -> any
+        raise NotImplementedError("IMPL ME")
+
+    def dumps(self, data):
+        # type: (any) -> any
+        raise NotImplementedError("IMPL ME")

s1zlibs/jsoner/fields/simple_field.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from sys import version_info
+from .base_field import BaseField
+from ..serializers.base_serializer import BaseSerializer
+from ..serializers.simple_serializer import SimpleSerializer
+from ..exceptions import FieldRequired
+
+if version_info[0] == 3:
+    unicode = str
+
+
+TAG = __name__
+
+
+class SimpleField(BaseField):
+
+    _field_name = None  # type: unicode
+    _field_type = None  # type: any
+    _serializer = None  # type: BaseSerializer
+
+    def __init__(self, field_type, field_name=None,
+                 serializer=SimpleSerializer):
+        """
+        :param field_type: The type of field's value
+        :param field_name: The name of the field
+        :param serializer: The serializer of the field value
+        :param null: Set's whether value can be null or not
+        """
+        self._field_type = field_type
+        self._field_name = field_name
+        self._serializer = serializer(field_type)
+
+    def loads(self, value):
+        return self._serializer.loads(value)
+
+    def dumps(self, value):
+        return self._serializer.dumps(value)

s1zlibs/jsoner/functions.py

@@ -5,33 +5,33 @@ from __future__ import unicode_literals
 def pythonize_str(data):
     # Converts name to a python style names:
     # simpleTestValue -> simple_test_value
-    name_len = len(data)
     new_data = ""
-    for i in range(name_len):
-        c = data[i]
-        if c.isupper():
-            new_data += "_" + c.lower()
+    for i in range(len(data)):
+        curr_chr = data[i]
+        if curr_chr.isupper():
+            new_data += "_" + curr_chr.lower()
         else:
-            new_data += c
+            new_data += curr_chr
     return new_data
 
 
 def jsonize_str(data):
     # Converts data to a json style names:
     # simple_test_value -> simpleTestValue
-    if data.find("_") == -1:
-        return data
-    name_len = len(data)
-    new_data = ""
-    for i in range(name_len):
-        c = data[i]
-        if c == "_":
+    new_data = ''
+    for i in range(len(data)):
+        curr_chr = data[i]
+        if curr_chr == '_':
             continue
-        elif i == 0 and c.isalpha():
-            new_data += c
-        elif c.isalpha():
-            if data[i - 1] == "_":
-                new_data += c.upper()
+        elif i == 0:
+            # first char is always lower case! don't care if it isn't alpha.
+            new_data += curr_chr.lower()
+        elif curr_chr.isalpha() and data[i - 1] == '_':
+            # If alpha and prev chr is '_' we push it in upper case.
+            new_data += curr_chr.upper()
+        elif not curr_chr.isalpha() and data[i - 1] == '_':
+            # If not alpha and we copy prev and curr not changed.
+            new_data += "_" + curr_chr
         else:
-                new_data += c
+            new_data += curr_chr
     return new_data

s1zlibs/jsoner/models/base_model.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from .decorators import with_metaclass
+from .meta_model import MetaModel
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+
+TAG = __name__
+
+
+@with_metaclass(MetaModel)
+class BaseModel(object):
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def loads(self, data):
+        raise NotImplementedError("IMPL ME")
+
+    def dumps(self):
+        raise NotImplementedError("IMPL ME")
+
+    @classmethod
+    def from_json(cls, data):
+        # type: (unicode) -> any
+        self = cls.__new__(cls)
+        return self.loads(json.loads(data))
+
+    def to_json(self):
+        # type: (any) -> unicode
+        return json.dumps(self.dumps())

s1zlibs/jsoner/models/decorators.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+
+
+TAG = __name__
+
+
+def with_metaclass(meta):
+    def decorator(cls):
+        # TODO(s1z): Please check this code!
+        attrs = vars(cls).copy()
+        attrs.pop('__dict__', None)
+        attrs.pop('__weakref__', None)
+        return meta(cls.__name__, cls.__bases__, attrs)
+    return decorator

s1zlibs/jsoner/models/functions.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+
+
+def pythonize_str(data):
+    # Converts name to a python style names:
+    # simpleTestValue -> simple_test_value
+    new_data = ""
+    for i in range(len(data)):
+        curr_chr = data[i]
+        if curr_chr.isupper():
+            new_data += "_" + curr_chr.lower()
+        else:
+            new_data += curr_chr
+    return new_data
+
+
+def jsonize_str(data):
+    # Converts data to a json style names:
+    # simple_test_value -> simpleTestValue
+    new_data = ''
+    for i in range(len(data)):
+        curr_chr = data[i]
+        if curr_chr == '_':
+            continue
+        elif i == 0:
+            # first char is always lower case! don't care if it isn't alpha.
+            new_data += curr_chr.lower()
+        elif curr_chr.isalpha() and data[i - 1] == '_':
+            # If alpha and prev chr is '_' we push it in upper case.
+            new_data += curr_chr.upper()
+        elif not curr_chr.isalpha() and data[i - 1] == '_':
+            # If not alpha and we copy prev and curr not changed.
+            new_data += "_" + curr_chr
+        else:
+            new_data += curr_chr
+    return new_data

s1zlibs/jsoner/models/list_model.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from .base_model import BaseModel
+
+
+TAG = __name__
+
+
+class ListModel(BaseModel):
+    def loads(self):
+        raise NotImplementedError("IMPL ME")
+
+    def dumps(self):
+        raise NotImplementedError("IMPL ME")

s1zlibs/jsoner/models/meta_model.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from ..fields.base_field import BaseField
+
+
+TAG = __name__
+
+
+JSONER_DATA_FIELD = "_jsoner_fields"
+
+
+class MetaModel(type):
+
+    def __new__(cls, name, bases, attrs):
+
+        # Creating a new class jsoner_field
+        jsoner_field_cls = attrs.pop(JSONER_DATA_FIELD, {})
+
+        # Creating a base classes jsoner_field
+        jsoner_field_base = {}
+
+        # Creating the new class
+        new_cls = super(MetaModel, cls).__new__(cls, name, bases, attrs)
+
+        # Copying base blasses jsoner_fields
+        for base in bases:
+            if hasattr(base, JSONER_DATA_FIELD):
+                jsoner_field_base.update(getattr(base, JSONER_DATA_FIELD, {}))
+
+        # Setting the new class jsoner_field
+        for k, v in attrs.items():
+            if isinstance(v, BaseField):
+                # Here's the place where the magic comes!
+                jsoner_field_cls[k] = v
+
+                def get_value(self):
+                    return v.get_value()
+
+                def set_value(self, value):
+                    return v.set_value(value)
+
+                def del_value(self):
+                    return v.del_value()
+
+                setattr(new_cls, k, property(get_value,
+                                             set_value,
+                                             del_value))
+        jsoner_field = dict()
+        jsoner_field.update(jsoner_field_base)
+        jsoner_field.update(jsoner_field_cls)  # overwrites base fields!
+        setattr(new_cls, JSONER_DATA_FIELD, jsoner_field)
+        return new_cls
+
+    def __call__(cls, *args, **kwargs):
+        instance = type.__call__(cls)
+        for name, field in getattr(instance, JSONER_DATA_FIELD, {}).items():
+            if name in kwargs:
+                setattr(instance, name, kwargs.get(name))
+        return type.__call__(cls)

s1zlibs/jsoner/models/object_model.py

+from __future__ import absolute_import
+from __future__ import unicode_literals
+from .meta_model import JSONER_DATA_FIELD
+from .base_model import BaseModel
+from .functions import pythonize_str, jsonize_str
+from ..exceptions import FieldRequired
+
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+
+TAG = __name__
+
+
+class ObjectModel(BaseModel):
+
+    def loads(self, data):
+        # type: (dict) -> any
+        fields = getattr(self, JSONER_DATA_FIELD, {})
+        for field_name, field in fields.items():
+            j_field_name = field.get_field_name() or jsonize_str(field_name)
+            loaded_value = data.get(j_field_name, None)
+            j_field_value = field.loads(loaded_value)
+            setattr(self, field_name, j_field_value)
+        return self
+
+    def dumps(self):
+        # type: () -> dict
+        dumped = dict()
+        instance_fields = getattr(self, JSONER_DATA_FIELD, {})
+        for field_name, field in instance_fields.items():
+            j_field_name = field.get_field_name() or jsonize_str(field_name)
+            if field.is_value_set():
+                dumped_value = getattr(self, field_name, None)
+                j_field_value = field.dumps(dumped_value)
+                dumped[j_field_name] = j_field_value
+        return dumped

s1zlibs/jsoner/serializable/base_serializable.py

-from __future__ import absolute_import
-from __future__ import unicode_literals
-
-
-_field_name = "_jsoner_data"
-
-
-
-

s1zlibs/jsoner/serializers/base_serializer.py

 from __future__ import absolute_import
 from __future__ import unicode_literals
-from abc import ABCMeta
-from abc import abstractmethod
-from ..decorators import with_metaclass
 
 
-@with_metaclass(ABCMeta)
 class BaseSerializer(object):
 
-    @abstractmethod
     def loads(self, data):
         # type: (bytes) -> BaseSerializer
-        raise NotImplementedError("IMPL ME")
+        pass
 
-    @abstractmethod
     def dumps(self, data):
-        # type: (any) -> bytes
-        raise NotImplementedError("IMPL ME")
+        # type: (any) -> any
+        pass
\ No newline at end of file

s1zlibs/jsoner/serializers/simple_serializer.py

 from __future__ import absolute_import
 from __future__ import unicode_literals
-from ...utils.log import Log
-from .base_serializer import BaseSerializer
 from sys import version_info
 
+from .base_serializer import BaseSerializer
+from utils.log import Log
+
 
 TAG = "SimpleSerializer"
 
@@ -65,6 +66,9 @@ class SimpleSerializer(BaseSerializer):
         self.raise_value_error(value, [self.value_type])
 
     def dumps(self, value):
+        if value is None:
+            return value
+
         if not self.value_is_list and not isinstance(value, list):
             self.check_type([value])
             return value

s1zlibs/test.py

+#! /usr/bin/env python
+from __future__ import absolute_import
+from __future__ import unicode_literals
+from __future__ import print_function
+from jsoner.models.object_model import ObjectModel
+from jsoner.fields.simple_field import SimpleField
+
+
+class TestObject(ObjectModel):
+    zzz_z = SimpleField(int, 'lol')
+
+
+class Test2Object(TestObject):
+    zzz_a = SimpleField([int])
+
+
+def main():
+    test2 = Test2Object(zzz_z=1, zzz_a=[])
+    test3 = Test2Object.from_json(test2.to_json())
+
+
+if __name__ == "__main__":
+    main()

s1zlibs/utils/log.py

@@ -4,30 +4,40 @@ import traceback
 import logging
 
 
+def init_logging(filename=None, level=None):
+    logging_config = {"format": "%(asctime)-23s %(levelname)8s: %(message)s",
+                      "level": level or logging.INFO}
+    if filename is not None:
+        logging_config["filename"] = filename
+    logging.getLogger().handlers = []
+    logging.basicConfig(**logging_config)
+
+
 try:
     import threading
-except ImportError: #pragma: no cover
+except ImportError:  # pragma: no cover
     threading = None
 
 
 if threading:
     _lock = threading.RLock()
-else: #pragma: no cover
+else:  # pragma: no cover
     _lock = None
 
 
-def _acquireLock():
+def _acquire_lock():
     """
     Acquire the module-level lock for serializing access to shared data.
 
-    This should be released with _releaseLock().
+    This should be released with _release_lock().
     """
     if _lock:
         _lock.acquire()
 
-def _releaseLock():
+
+def _release_lock():
     """
-    Release the module-level lock acquired by calling _acquireLock().
+    Release the module-level lock acquired by calling _acquire_lock().
     """
     if _lock:
         _lock.release()
@@ -35,32 +45,26 @@ def _releaseLock():
 
 class Log(object):
 
-    logger = logging.getLogger()
+    LEVEL = logging.DEBUG
+
     handler = logging.StreamHandler()
+    handler.setLevel(LEVEL)
 
-    handler.setLevel(logging.DEBUG)
-    logger.setLevel(logging.DEBUG)
+    logger = logging.getLogger()
+    logger.setLevel(LEVEL)
     logger.addHandler(handler)
 
-    tags = dict()
-
     @staticmethod
-    def get_or_create_tag(tag):
-        # TODO(s1z): Finish this please
-        _acquireLock()
-        try:
-            if tag in Log.tags:
-                return Log.tags[tag]
-        finally:
-            _releaseLock()
+    def get_or_create_logger(tag):
+        return logging.getLogger(tag)
 
     @staticmethod
     def log(level, tag, message, ex):
+        # The tab should be the module.__name__ but not required!
         if ex is not None:
             # exc_type, exc_value, exc_traceback = sys.exc_info()
-            message = "%s\n%s" % (message, traceback.format_exc())
-        msg = "{}::{}".format(tag, message)
-        Log.logger.log(level, msg)
+            message = "%s\nTraceback:\n%s" % (message, traceback.format_exc())
+        logging.getLogger(tag).log(level, message)
 
     @staticmethod
     def v(tag, message, ex=None):

s1zlibs/utils/pbkdf2_hmac.py

-from __future__ import absolute_import
 from __future__ import unicode_literals
-from hashlib import new
-
-
-try:
-    range = xrange
-except NameError:
-    buffer = memoryview
+from __future__ import absolute_import
 
 
 try:
     # OpenSSL's PKCS5_PBKDF2_HMAC requires OpenSSL 1.0+ with HMAC and SHA
     from _hashlib import pbkdf2_hmac
 except ImportError:
+    from hashlib import new
     import binascii
     import struct
+    import sys
 
-    _trans_5C = bytes(bytearray([x ^ 0x5C for x in range(256)]))
-    _trans_36 = bytes(bytearray([x ^ 0x36 for x in range(256)]))
+    try:
+        range = xrange
+    except NameError:
+        unicode = str
+
+    _trans_5C = bytearray(x ^ 0x5C for x in range(256))
+    _trans_36 = bytearray(x ^ 0x36 for x in range(256))
+
+    def data_to_bytes(data, encoding="utf-8"):
+        if sys.version_info < (3, 0):
+            return bytes(data)
+        else:
+            return bytes(data, encoding)
 
     def pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None):
         """Password based key derivation function 2 (PKCS #5 v2.0)
@@ -26,18 +32,19 @@ except ImportError:
         as OpenSSL's PKCS5_PBKDF2_HMAC for short passwords and much faster
         for long passwords.
         """
-        if not isinstance(hash_name, str):
+        if not isinstance(hash_name, (str, unicode)):
             raise TypeError(hash_name)
 
         if not isinstance(password, (bytes, bytearray)):
-            raise TypeError("a bytes-like object is required, not '{}'".format(
-                type(password).__name__
-            ))
-
+            error = "a bytes-like object is required, not '{}'".format(
+                password.__class__.__name__
+            )
+            raise TypeError(error)
         if not isinstance(salt, (bytes, bytearray)):
-            raise TypeError("a bytes-like object is required, not '{}'".format(
-                type(salt).__name__
-            ))
+            error = "a bytes-like object is required, not '{}'".format(
+                salt.__class__.__name__
+            )
+            raise TypeError(error)
 
         # Fast inline HMAC implementation
         inner = new(hash_name)
@@ -79,3 +86,7 @@ except ImportError:
             dkey += binascii.unhexlify(hex_format_string % rkey)
 
         return dkey[:dklen]
+
+
+def pbkdf(secret, salt, hash="sha256", iterations=10000, dklen=128):
+    return pbkdf2_hmac(hash, secret, salt, iterations, dklen)

setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="s1zlibs",
-    version="1.0.6",
+    version="1.0.7",
     author="Barabash Oleksandr",
     author_email="skaltmn@gmail.com",
     description="s1zlibs",