DefStream 0.1.2__py3-none-any.whl

DefStream/Descriptor/Value.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+
+from collections.abc import Mapping
+
+from enum import  Enum
+
+from typing import Any, Iterator, KeysView, ItemsView, ValuesView
+from typing import Optional, Sequence, Dict, Union, Iterable, Tuple
+from abc import ABCMeta, ABC
+
+__all__ = (
+	'Type',
+	'Value',
+	'Condition',
+	'Schema',
+	'OneOf',
+	'AllOf',
+	'TypeMapper',
+	'TypeEncoder',
+)
+
+
+class Descriptor(Mapping):
+	def __init__(self, **kwargs: Dict[str, Union['Value', 'Schema']]):
+		self.__properties__ = kwargs
+		return
+
+	def __getitem__(self, key: Any) -> Any:
+		return self.__properties__.__getitem__(key)
+	
+	def __setitem__(self, key: Any, value: Any) -> None:
+		return self.__properties__.__setitem__(key, value)
+	
+	def __delitem__(self, key: Any) -> None:
+		return self.__properties__.__delitem__(key)
+	
+	def __iter__(self) -> Iterator:
+		return self.__properties__.__iter__()
+	
+	def __len__(self) -> int:
+		return self.__properties__.__len__()
+	
+	def __contains__(self, key: object) -> bool:
+		return self.__properties__.__contains__(key)
+	
+	def keys(self) -> KeysView:
+		return self.__properties__.keys()
+	
+	def items(self) -> ItemsView:
+		return self.__properties__.items()
+	
+	def values(self) -> ValuesView:
+		return self.__properties__.values()
+	
+	def __eq__(self, other: object) -> bool:
+		return self.__properties__.__eq__(other)
+	
+	def __ne__(self, value: object) -> bool:
+		return self.__properties__.__ne__(value)
+	
+	def get(self, key: object) -> Any:
+		return self.__properties__.get(key)
+
+
+class Type(str, Enum):
+	Boolean = 'boolean'
+	Integer = 'integer'
+	Number = 'number'
+	String = 'string'
+	Array = 'array'
+	Object = 'object'
+
+
+class Value(Descriptor):
+	def __init__(
+		self, 
+		type: Type,
+		description: str = None,
+		format: str = None,
+		min: Any = None,
+		max: Any = None,
+		default: Any = None,
+		enum: Optional[Iterable[Any]] = None,
+		required: bool = True,
+	):
+		super().__init__(type=type)
+		if description: self['description'] = description
+		if format: self['format'] = format
+		if min is not None: self['minimum'] = min
+		if max is not None: self['maximum'] = max
+		if not required: self['default'] = default
+		if enum: self['enum'] = enum
+		self.required = required
+		return
+
+
+class Condition(ABC):
+	def __init__(self, *args):
+		self.args = args
+		return
+
+
+class Schema(object):
+	def __init__(
+		self,
+		name: str,
+		format: Union[Value, Condition] = None,
+	):
+		self.name = name
+		self.format = format
+		return
+
+
+class OneOf(Condition):
+	def __init__(self, *args: Iterable[Union[Value, Schema]], discriminator: str = None, required: bool = True):
+		self.args = args
+		self.discriminator = discriminator
+		self.required = required
+		return
+
+
+class AllOf(Condition): pass
+
+
+class TypeMapper(metaclass=ABCMeta):
+	def __call__(self, o: type) -> Tuple[Value, Dict[str, Any]]:
+		raise NotImplementedError('{} must be implemented __call__'.format(self.__class__.__name__))
+
+
+class TypeEncoder(metaclass=ABCMeta):
+	def __call__(self, o: Any) -> Any:
+		raise NotImplementedError('{} must be implemented __call__'.format(self.__class__.__name__))

DefStream/Descriptor/__init__.py

@@ -0,0 +1,172 @@
+from collections.abc import (
+	Mapping,
+	Sequence,
+)
+from dataclasses import is_dataclass
+from json import (
+	dumps,
+	loads,
+)
+from typing import (
+	Any,
+	Optional,
+	Type,
+)
+
+from .Value import (
+	Value,
+	Condition,
+	Schema,
+	OneOf,
+	AllOf,
+	TypeMapper,
+	TypeEncoder,
+)
+from .Types import (
+	Boolean,
+	IntegerFormat,
+	Integer,
+	NumberFormat,
+	Number,
+	StringFormat,
+	String,
+	Binary,
+	BinaryBase64Encoded,
+	Array,
+	Object,
+	Properties,
+)
+from .DataObject import (
+	DataObjectToSchema,
+	DataObjectToObject,
+)
+
+__all__ = (
+	'Value',
+	'Condition',
+	'Schema',
+	'OneOf',
+	'AllOf',
+	'TypeMapper',
+	'TypeEncoder',
+	'Boolean',
+	'IntegerFormat',
+	'Integer',
+	'NumberFormat',
+	'Number',
+	'StringFormat',
+	'String',
+	'Binary',
+	'BinaryBase64Encoded',
+	'Array',
+	'Object',
+	'Properties',
+	'ToSchema',
+	'DumpSchema',
+	'ToObject',
+)
+
+
+def schema_value(
+	value: Any,
+) -> Any:
+	if isinstance(
+		value,
+		Schema,
+	):
+		return schema_value(value.format)
+	if isinstance(
+		value,
+		Condition,
+	):
+		if isinstance(
+			value,
+			OneOf,
+		):
+			key = 'oneOf'
+		elif isinstance(
+			value,
+			AllOf,
+		):
+			key = 'allOf'
+		else:
+			raise TypeError('Unsupported schema condition: ' + type(value).__name__)
+		return {key: [schema_value(arg) for arg in value.args]}
+	if isinstance(
+		value,
+		Mapping,
+	):
+		return {
+			key: schema_value(item) for key, item in value.items()
+		}
+	if isinstance(
+		value,
+		Sequence,
+	) and not isinstance(
+		value,
+		(
+			str,
+			bytes,
+			bytearray,
+		),
+	):
+		return [schema_value(item) for item in value]
+	if value is None or isinstance(
+		value,
+		(
+			str,
+			int,
+			float,
+			bool,
+		),
+	):
+		return value
+	raise TypeError('Unsupported schema value: ' + type(value).__name__)
+
+
+def DumpSchema(
+	o: Schema,
+) -> dict:
+	if not isinstance(
+		o,
+		Schema,
+	):
+		raise TypeError('A Schema is required')
+	result = schema_value(o)
+	if not isinstance(
+		result,
+		dict,
+	):
+		raise TypeError('A schema must describe an object, value or condition')
+	return loads(dumps(
+		result,
+		allow_nan=False,
+	))
+
+
+def ToSchema(
+	o: Type[object],
+	description: Optional[str] = None,
+	typedef: Optional[TypeMapper] = None,
+) -> Schema:
+	if not isinstance(
+		o,
+		type,
+	) or not is_dataclass(o):
+		raise TypeError('A dataclass type is required')
+	return DataObjectToSchema(mapper=typedef)(
+		o,
+		description,
+	)
+
+
+def ToObject(
+	o: object,
+	typeenc: Optional[TypeEncoder] = None,
+) -> dict:
+	if isinstance(
+		o,
+		type,
+	) or not is_dataclass(o):
+		raise TypeError('A dataclass instance is required')
+	return DataObjectToObject(encoder=typeenc)(o)

DefStream/Inspector/Extension.py

@@ -0,0 +1,69 @@
+from abc import (
+	ABC,
+	abstractmethod,
+)
+from typing import (
+	Optional,
+	TYPE_CHECKING,
+)
+
+from .Response import Response
+
+if TYPE_CHECKING:
+	from .Inspector import Inspector
+
+__all__ = (
+	'Extension',
+)
+
+
+class Extension(ABC):
+	methods = (
+		'GET',
+		'HEAD',
+	)
+
+	def __init__(
+		self,
+		path: str,
+	):
+		if not isinstance(
+			path,
+			str,
+		) or not path.startswith('/') or '?' in path or '#' in path:
+			raise ValueError('An absolute HTTP path without a query or fragment is required')
+		self.path = path
+
+	def start(
+		self,
+		inspector: 'Inspector',
+	) -> None:
+		pass
+
+	def begin(
+		self,
+		task: str,
+	) -> object:
+		return None
+
+	def end(
+		self,
+		task: str,
+		context: object,
+		success: Optional[bool],
+	) -> None:
+		pass
+
+	def handle(
+		self,
+		inspector: 'Inspector',
+		environ: dict,
+	) -> Response:
+		return self(inspector)
+
+	@abstractmethod
+	def __call__(
+		self,
+		inspector: 'Inspector',
+	) -> Response:
+		raise NotImplementedError