代码拉取完成，页面将自动刷新
utype is a data types declaration & parsing library based on Python type annotations, enforce types and constraints for classes and functions at runtime
pip install -U utype
utype requires Python >= 3.7
The utype support to add constraints on types, such as
from utype import Rule, exc
class PositiveInt(int, Rule):
gt = 0
assert PositiveInt(b'3') == 3
try:
PositiveInt(-0.5)
except exc.ParseError as e:
print(e)
"""
Constraint: 0 violated
"""
Data that conforms to the type and constraints will complete the conversion, otherwise will throw a parse error indicating what went wrong
utype supports the "dataclass" usage that convert a dict or JSON to a class instance, similar to pydantic and attrs
from utype import Schema, Field, exc
from datetime import datetime
class UserSchema(Schema):
username: str = Field(regex='[0-9a-zA-Z]{3,20}')
signup_time: datetime
# 1. Valid input
data = {'username': 'bob', 'signup_time': '2022-10-11 10:11:12'}
print(UserSchema(**data))
#> UserSchema(username='bob', signup_time=datetime.datetime(2022, 10, 11, 10, 11, 12))
# 2. Invalid input
try:
UserSchema(username='@invalid', signup_time='2022-10-11 10:11:12')
except exc.ParseError as e:
print(e)
"""
parse item: ['username'] failed:
Constraint: <regex>: '[0-9a-zA-Z]{3,20}' violated
"""
After a simple declaration, you can get
__init__ to take input data, perform validation and attribute assignment__repr__ and __str__ to get the clearly print output of the instanceutype can also parse function params and result
import utype
from typing import Optional
class PositiveInt(int, utype.Rule):
gt = 0
class ArticleSchema(utype.Schema):
id: Optional[PositiveInt]
title: str = utype.Field(max_length=100)
slug: str = utype.Field(regex=r"[a-z0-9]+(?:-[a-z0-9]+)*")
@utype.parse
def get_article(id: PositiveInt = None, title: str = '') -> ArticleSchema:
return {
'id': id,
'title': title,
'slug': '-'.join([''.join(
filter(str.isalnum, v)) for v in title.split()]).lower()
}
print(get_article('3', title=b'My Awesome Article!'))
#> ArticleSchema(id=3, title='My Awesome Article!', slug='my-awesome-article')
try:
get_article('-1')
except utype.exc.ParseError as e:
print(e)
"""
parse item: ['id'] failed: Constraint: : 0 violated
"""
try:
get_article(title='*' * 101)
except utype.exc.ParseError as e:
print(e)
"""
parse item: ['<return>'] failed:
parse item: ['title'] failed:
Constraint: <max_length>: 100 violated
"""
You can easily get type checking and code completion of IDEs (such as Pycharm, VS Code) during development
utype supports not only normal functions, but also generator functions, asynchronous functions, and asynchronous generator functions with the same usage
import utype
import asyncio
from typing import AsyncGenerator
@utype.parse
async def waiter(rounds: int = utype.Param(gt=0)) -> AsyncGenerator[int, float]:
assert isinstance(rounds, int)
i = rounds
while i:
wait = yield str(i)
if wait:
assert isinstance(wait, float)
print(f'sleep for: {wait} seconds')
await asyncio.sleep(wait)
i -= 1
async def wait():
wait_gen = waiter('2')
async for index in wait_gen:
assert isinstance(index, int)
try:
await wait_gen.asend(b'0.5')
# sleep for: 0.5 seconds
except StopAsyncIteration:
return
if __name__ == '__main__':
asyncio.run(wait())
The
AsyncGeneratortype is used to annotate the return value of the asynchronous generator, which has two parameters: the type of the value output byyield, type of the value sent byasend
As you can see, the parameters passed to the function and the value received from yield were all converted to the expected type as declared
utype supports logical operations on types and data structures using Python-native logical operators
from utype import Schema, Field
from typing import Tuple
class User(Schema):
name: str = Field(max_length=10)
age: int
one_of_user = User ^ Tuple[str, int]
print(one_of_user({'name': 'test', 'age': '1'}))
# > User(name='test', age=1)
print(one_of_user([b'test', '1']))
# > ('test', 1)
The example uses the ^ exclusive or symbol to logically combine User and Tuple[str, int], and the new logical type gains the ability to convert data to one of those
Type transformation and validation strictness required by each project may be different, so in utype, all types support registraton, extension and override, such as
from utype import Rule, Schema, register_transformer
from typing import Type
class Slug(str, Rule):
regex = r"[a-z0-9]+(?:-[a-z0-9]+)*"
@register_transformer(Slug)
def to_slug(transformer, value, t: Type[Slug]):
str_value = transformer(value, str)
return t('-'.join([''.join(
filter(str.isalnum, v)) for v in str_value.split()]).lower())
class ArticleSchema(Schema):
slug: Slug
print(dict(ArticleSchema(slug=b'My Awesome Article!')))
# > {'slug': 'my-awesome-article'}
You can register transformers not only for custom types, but also for basic types (such as str, int, etc.) Or types in the standard library (such as datetime, Enum, etc.) To customize the conversion behavior
utype is still growing, and the following features are planned for implementation in the new version
You are also welcome to contribute features or submit issues.
UtilMeta Python Framework is a progressive meta-framework for backend applications, which efficiently builds declarative APIs based on the Python type annotation standard, and supports the integration of mainstream Python frameworks as runtime backend
utype is a project of UtilMeta, so you can join the community in
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。