DefStream 0.1.2__py3-none-any.whl

DefStream/Descriptor/DataObject.py

@@ -0,0 +1,384 @@
+# -*- coding: utf-8 -*-
+
+from .Value import (
+	Value,
+	Schema,
+	OneOf,
+	TypeMapper,
+	TypeEncoder,
+)
+
+from .Types import (
+	Boolean,
+	Integer,
+	Number,
+	String,
+	Binary,
+	Array,
+	Object,
+	Properties,
+)
+
+from dataclasses import is_dataclass, MISSING, asdict
+from json import dumps, loads
+from typing import (
+	Type,
+	Any,
+	Union,
+	Sequence,
+	Iterable,
+	Annotated,
+	get_origin,
+	get_args,
+	get_type_hints,
+	ForwardRef,
+)
+
+__all__ = (
+	'SchemaToDataObject',
+	'DataObjectToSchema',
+	'DataObjectToObject',
+)
+
+
+def SchemaToDataObject(o: Schema, name: str = None) -> object:
+	# TODO : make dataclass according to schema dynamically
+	raise NotImplementedError('SchemaToDataObject is not implemented yet')
+
+
+class DataObjectToSchema(object):
+	def __init__(self, mapper: TypeMapper = None):
+		self.mapper = mapper
+		return
+	def __value__(
+		self,
+		o: type,
+		format: Union[type, Sequence[type]] = None,
+		description: str = None,
+		required: bool = True,
+		default: Any = MISSING,
+		metadata: Any = None,
+	) -> Union[Value, Schema]:
+		args = get_args(o)
+		o = get_origin(o) if get_origin(o) else o
+		if args:
+			if len(args) == 1:
+				if o is list:
+					return self.__value__(
+						list,
+						format=args[0],
+						description=description,
+						required=required,
+						default=default,
+						metadata=metadata,
+					)
+				if o is tuple:
+					return self.__value__(
+						tuple,
+						format=args[0],
+						description=description,
+						required=required,
+						default=default,
+						metadata=metadata,
+					)
+				if o is set:
+					return self.__value__(
+						set,
+						format=args[0],
+						description=description,
+						required=required,
+						default=default,
+						metadata=metadata,
+					)
+				if o is Union:
+					return self.__value__(
+						Union,
+						format=args[0],
+						description=description,
+						required=required,
+						default=default,
+						metadata=metadata,
+					)
+				raise TypeError('{} is not a supported type'.format(o))
+			if len(args) == 2:
+				if o is Union:
+					if args[0] is type(None): # Union[type, None]
+						return self.__value__(
+							args[1],
+							description=description,
+							required=False,
+							default=None,
+							metadata=metadata,
+						)
+					if args[1] is type(None): # Union[None, type]
+						return self.__value__(
+							args[0],
+							description=description,
+							required=False,
+							default=None,
+							metadata=metadata,
+						)
+					# Union[type, type]
+					return self.__value__(
+						o,
+						format=(args[0], args[1]),
+						description=description,
+						required=required,
+						default=default,
+						metadata=metadata,
+					)
+				if o is dict: # Dict[type, type]
+					return self.__value__(
+						dict,
+						description=description,
+						required=required,
+						default=default,
+						metadata=metadata,
+					)
+				if o is Annotated:
+					if isinstance(args[1], str):
+						return self.__value__(
+							args[0],
+							description=args[1],
+							required=required,
+							default=default,
+						)
+					return self.__value__(
+						args[0],
+						description=description,
+						required=required,
+						default=default,
+						metadata=args[1],
+					)
+				raise TypeError('{} is not a supported type'.format(o))	
+			if o is Union:
+				fs= [self.__value__(f) for f in args]
+				return OneOf(*fs, required=required)
+			if o is Annotated:
+				if isinstance(args[1], str):
+					return self.__value__(
+						args[0],
+						description=args[1],
+						required=required,
+						default=default,
+						metadata=args[2] if isinstance(args[2], dict) else args[2:],
+					)
+				if isinstance(args[2], str):
+					return self.__value__(
+						args[0],
+						description=args[2],
+						required=required,
+						default=default,
+						metadata=args[1],
+					)
+				return self.__value__(
+					args[0],
+					description=description,
+					required=required,
+					default=default,
+					metadata=args[1:],
+				)
+			raise TypeError('{} is not a supported type'.format(o))	
+		if o is bool:
+			kwargs = {
+				'description': description,
+				'required': required,
+			}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if metadata and isinstance(metadata, dict):
+				if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+				if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+			return Boolean(**kwargs)
+		if o is int:
+			kwargs = {
+				'description': description,
+				'required': required,
+			}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if metadata and isinstance(metadata, dict):
+				if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+				if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+				if 'format' in metadata.keys(): kwargs['format'] = metadata['format']
+				if 'min' in metadata.keys(): kwargs['min'] = metadata['min']
+				if 'max' in metadata.keys(): kwargs['max'] = metadata['max']
+				if 'enum' in metadata.keys(): kwargs['enum'] = metadata['enum']
+			return Integer(**kwargs)
+		if o is float:
+			kwargs = {
+				'description': description,
+				'required': required,
+			}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if metadata and isinstance(metadata, dict):
+				if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+				if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+				if 'format' in metadata.keys(): kwargs['format'] = metadata['format']
+				if 'min' in metadata.keys(): kwargs['min'] = metadata['min']
+				if 'max' in metadata.keys(): kwargs['max'] = metadata['max']
+				if 'enum' in metadata.keys(): kwargs['enum'] = metadata['enum']
+			return Number(**kwargs)
+		if o is str:
+			kwargs = {
+				'description': description,
+				'required': required,
+			}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if metadata and isinstance(metadata, dict):
+				if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+				if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+				if 'format' in metadata.keys(): kwargs['format'] = metadata['format']
+				if 'min' in metadata.keys(): kwargs['min'] = metadata['min']
+				if 'max' in metadata.keys(): kwargs['max'] = metadata['max']
+				if 'enum' in metadata.keys(): kwargs['enum'] = metadata['enum']
+			return String(**kwargs)
+		if o is bytes:
+			kwargs = {
+				'description': description,
+				'required': required,
+			}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if metadata and isinstance(metadata, dict):
+				if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+				if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+			return Binary(**kwargs)
+		if o is list:
+			kwargs = {
+				'description': description,
+				'required': required,
+			}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if metadata and isinstance(metadata, dict):
+				if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+				if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+				if 'format' in metadata.keys():
+					if not isinstance(metadata['format'], Iterable):
+						metadata['format'] = [metadata['format']]
+					if len(metadata['format']) == 1:
+						metadata['format'] = self.__value__(metadata['format'][0])
+					fs = [self.__value__(f) for f in metadata['format']]
+					kwargs['format'] = OneOf(*fs)
+			if format:
+				if not isinstance(format, Iterable):
+					format = [format]
+				if len(format) == 1:
+					f = self.__value__(format[0])
+					return Array(format=f, **kwargs)
+				fs = [self.__value__(f) for f in format]
+				return Array(format=OneOf(*fs), **kwargs)
+			else:
+				return Array(**kwargs)
+		if o is tuple:
+			kwargs = {
+				'description': description,
+				'required': required,
+			}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if metadata and isinstance(metadata, dict):
+				if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+				if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+			return Array(**kwargs)
+		if o is set:
+			kwargs = {
+				'description': description,
+				'required': required,
+			}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if metadata and isinstance(metadata, dict):
+				if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+				if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+			return Array(**kwargs)
+		if o is dict:
+			kwargs = {
+				'description': description,
+				'required': required,
+			}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if metadata and isinstance(metadata, dict):
+				if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+				if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+			return Object(**kwargs)
+		if o is Union:
+			kwargs = {}
+			if default is not MISSING:
+				kwargs['default'] = default
+			if not format:
+				raise TypeError('Union type must have format')
+			if not isinstance(format, Iterable):
+				format = [format]
+			return OneOf(*[self.__value__(f) for f in format], **kwargs)
+		if is_dataclass(o):
+			return self.__call__(o, required=required)
+		if isinstance(o, ForwardRef):
+			if o.__forward_arg__ in globals():
+				return self.__value__(globals()[o.__forward_arg__], description=description, required=required, default=default, metadata=metadata)
+			if o.__forward_arg__ in locals():
+				return self.__value__(locals()[o.__forward_arg__], description=description, required=required, default=default, metadata=metadata)
+			raise TypeError('Cannot resolve schema forward reference: ' + o.__forward_arg__)
+		if self.mapper:
+			V, kws = self.mapper(o)
+			if V:
+				if not issubclass(V, Value):
+					raise TypeError('{} is not a Value'.format(V))
+				kwargs = {
+					'description': description,
+					'required': required,
+				}
+				if default is not MISSING:
+					kwargs['default'] = default
+				if metadata and isinstance(metadata, dict):
+					if 'description' in metadata.keys(): kwargs['description'] = metadata['description']
+					if 'required' in metadata.keys(): kwargs['required'] = metadata['required']
+					if V in (Integer, Number, String):
+						if 'format' in metadata.keys(): kwargs['format'] = metadata['format']
+						if 'min' in metadata.keys(): kwargs['min'] = metadata['min']
+						if 'max' in metadata.keys(): kwargs['max'] = metadata['max']
+						if 'enum' in metadata.keys(): kwargs['enum'] = metadata['enum']
+				kwargs.update(kws)
+				return V(**kwargs)
+		raise TypeError('{} is not a supported type'.format(o))
+
+	def __call__(self, o: Type[object], description: str = None, required: bool = True) -> Schema:
+		if not is_dataclass(o):
+			raise TypeError('{} is not a DataObject(dataclass).'.format(o.__name__))
+		hints = get_type_hints(o, include_extras=True)
+		return Schema(
+			name=description or o.__name__,
+			format=Object(
+				description=description or o.__name__,
+				properties=Properties(
+					**{
+						f.name: self.__value__(
+							hints[f.name],
+							required=True if f.default is MISSING and f.default_factory is MISSING else False,
+							default=f.default_factory() if f.default_factory is not MISSING else f.default,
+						) for f in o.__dataclass_fields__.values()
+					}
+				),
+				required=required,
+			)
+		)
+
+
+class DataObjectToObject(object):
+	def __init__(self, encoder: TypeEncoder = None):
+		self.encoder = encoder
+		return
+
+	def __call__(self, o: object):
+		if not is_dataclass(o):
+			raise TypeError('{} is not a DataObject(dataclass).'.format(o.__class__.__name__))
+		_ = dumps(
+			asdict(o),
+			default=self.encoder,
+			ensure_ascii=False,
+		)
+		return loads(_)

DefStream/Descriptor/Types.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+
+from .Value import Descriptor, Type, Value, Condition, Schema
+from typing import Optional, Union, Sequence, Any, Dict, Iterable 
+from enum import Enum
+
+__all__ = (
+	'Boolean',
+	'IntegerFormat',
+	'Integer',
+	'NumberFormat',
+	'Number',
+	'StringFormat',
+	'String',
+	'Binary',
+	'BinaryBase64Encoded',
+	'Array',
+	'Object',
+	'Properties',
+)
+
+
+class Boolean(Value):
+	def __init__(
+		self, 
+		description: str = None,
+		default: Any = None,
+		required: bool = True,
+	):
+		super().__init__(
+			type=Type.Boolean,
+			description=description,
+			default=default,
+			required=required,
+		)
+		return
+
+
+class IntegerFormat(str, Enum):
+	int32 = 'int32'
+	int64 = 'int64'
+	uint32 = 'uint32'
+	uint64 = 'uint64'
+	byte = 'byte'
+	uuid = 'uuid'
+	datetime = 'date-time'
+	def __str__(self): return self.value
+
+
+class Integer(Value):
+	def __init__(
+		self, 
+		description: str = None,
+		format: Union[str, IntegerFormat] = None,
+		min: Any = None,
+		max: Any = None,
+		default: Any = None,
+		enum: Optional[Sequence[str]] = None,
+		required: bool = True,
+	):
+		super().__init__(
+			type=Type.Integer,
+			description=description,
+			format=str(format) if format and isinstance(format, IntegerFormat) else format,
+			min=min,
+			max=max,
+			default=default,
+			enum=enum,
+			required=required,
+		)
+		return
+
+
+class NumberFormat(str, Enum):
+	float = 'float'
+	double = 'double'
+	decimal = 'decimal'
+	def __str__(self): return self.value
+
+
+class Number(Value):
+	def __init__(
+		self, 
+		description: str = None,
+		format: Union[str, NumberFormat] = None,
+		min: Any = None,
+		max: Any = None,
+		default: Any = None,
+		enum: Optional[Sequence[str]] = None,
+		required: bool = True,
+	):
+		super().__init__(
+			type=Type.Number,
+			description=description,
+			format=str(format) if format and isinstance(format, NumberFormat) else format,
+			min=min,
+			max=max,
+			default=default,
+			enum=enum,
+			required=required,
+		)
+		return
+
+
+class StringFormat(str, Enum):
+	datetime = 'date-time' # date-time, ISO 8601
+	date = 'date' # date, ISO 8601
+	time = 'time' # time, ISO 8601
+	password = 'password' # password
+	byte = 'byte' # byte, base64 encoded
+	binary = 'binary' # binary
+	email = 'email' # email
+	uuid = 'uuid' # uuid
+	uri = 'uri' # uri
+	hostname = 'hostname' # hostname
+	ipv4 = 'ipv4' # ipv4
+	ipv6 = 'ipv6' # ipv6
+	regex = 'regex' # regex
+	xml = 'xml' # xml
+	def __str__(self): return self.value
+
+
+class String(Value):
+	def __init__(
+		self, 
+		description: str = None,
+		format: Union[str, StringFormat] = None,
+		min: Any = None,
+		max: Any = None,
+		default: Any = None,
+		enum: Optional[Sequence[str]] = None,
+		required: bool = True,
+	):
+		super().__init__(
+			type=Type.String,
+			description=description,
+			format=str(format) if format and isinstance(format, StringFormat) else format,
+			min=min,
+			max=max,
+			default=default,
+			enum=enum,
+			required=required,
+		)
+		if min is not None:
+			del self['minimum']
+			self['minLength'] = min
+		if max is not None:
+			del self['maximum']
+			self['maxLength'] = max
+		return
+
+
+class BinaryBase64Encoded(String):
+	def __init__(
+		self, 
+		description: str = None,
+		default: str = None,
+		required: bool = True,
+	):
+		super().__init__(
+			description=description,
+			format=StringFormat.byte,
+			default=default,
+			required=required,
+		)
+		return
+
+
+class Binary(String):
+	def __init__(
+		self, 
+		description: str = None,
+		default: bytes = None,
+		required: bool = True,
+	):
+		super().__init__(
+			description=description,
+			format=StringFormat.binary,
+			default=default,
+			required=required,
+		)
+		return
+
+
+class Properties(Descriptor):
+	def __init__(self, **kwargs: Dict[str, Union[Value, Condition, Schema]]):
+		for k, v in kwargs.items():
+			kwargs[k] = v.format if isinstance(v, Schema) else v
+		super().__init__(**kwargs)
+		return 
+class Object(Descriptor):
+	def __init__(
+		self,
+		description: Optional[str] = None,
+		properties: Optional[Properties] = None,
+		default: Dict = None,
+		required: bool = True,
+	):
+		properties = properties if properties is not None else Properties()
+		super().__init__(
+			type=Type.Object,
+			properties=properties,
+		)
+		if description: self['description'] = description
+		self['required'] = []
+		for k, v in properties.items():
+			if hasattr(v, 'required') and getattr(v, 'required'):
+				self['required'].append(k)
+		if default is not None: self['default'] = default
+		self.required = required
+		return
+
+
+class Array(Descriptor):
+	def __init__(
+		self,
+		description: str = None,
+		format: Optional[Union[Value, Condition, Schema]] = None,
+		default: Iterable = None,
+		required: bool = True,
+	):
+		super().__init__(
+			type=Type.Array,
+		)
+		if description: self['description'] = description
+		if format: self['items'] = format.format if isinstance(format, Schema) else format
+		if default is not None: self['default'] = default
+		self.required = required
+		return