Skip to content

S
s1zlibs
Commit 449644aa by Oleksandr Barabash
Options

updated to 1.0.7

parent 5c018b7e
Showing with 800 additions and 373 deletions
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 0 → 100644
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 0 → 100644
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()
else:
new_data += c
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/base_model.py 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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")
\ No newline at end of file
# type: (any) -> any
pass
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 0 → 100644
#! /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 0 → 100644
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 0 → 100644
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()
else:
new_data += c
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/base_model.py 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 deleted 100644 → 0
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")
\ No newline at end of file
# type: (any) -> any
pass
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 0 → 100755
#! /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",
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment