class SettingsModel(BaseModel):
id_: UUID
access_token_life_mins: int = Schema(15, gt=1)
refresh_token_life_days: int = Schema(90, gt=1)
_name_field = "id_"
class ResultProperties(ProtoModel):
"""
Named properties of quantum chemistry computations following the MolSSI QCSchema.
"""
# Calcinfo
calcinfo_nbasis: Optional[int] = Schema(None, description="The number of basis functions for the computation.")
calcinfo_nmo: Optional[int] = Schema(None, description="The number of molecular orbitals for the computation.")
calcinfo_nalpha: Optional[int] = Schema(None, description="The number of alpha electrons in the computation.")
calcinfo_nbeta: Optional[int] = Schema(None, description="The number of beta electrons in the computation.")
calcinfo_natom: Optional[int] = Schema(None, description="The number of atoms in the computation.")
# Canonical
nuclear_repulsion_energy: Optional[float] = Schema(None, description="The nuclear repulsion energy energy.")
return_energy: Optional[float] = Schema(
None, description="The energy of the requested method, identical to `return_value` for energy computations.")
# SCF Keywords
scf_one_electron_energy: Optional[float] = Schema(
None, description="The one-electron (core Hamiltonian) energy contribution to the total SCF energy.")
scf_two_electron_energy: Optional[float] = Schema(
None, description="The two-electron energy contribution to the total SCF energy.")
scf_vv10_energy: Optional[float] = Schema(
None, description="The VV10 functional energy contribution to the total SCF energy.")
scf_xc_energy: Optional[float] = Schema(
None, description="The functional (XC) energy contribution to the total SCF energy.")
scf_dispersion_correction_energy: Optional[float] = Schema(
None,
description="The dispersion correction appended to an underlying functional when a DFT-D method is requested.")
scf_dipole_moment: Optional[List[float]] = Schema(None, description="The X, Y, and Z dipole components.")
scf_total_energy: Optional[float] = Schema(
None, description="The total electronic energy of the SCF stage of the calculation.")
scf_iterations: Optional[int] = Schema(None, description="The number of SCF iterations taken before convergence.")
# MP2 Keywords
mp2_same_spin_correlation_energy: Optional[float] = Schema(
None, description="The portion of MP2 doubles correlation energy from same-spin (i.e. triplet) correlations.")
mp2_opposite_spin_correlation_energy: Optional[float] = Schema(
None,
description="The portion of MP2 doubles correlation energy from opposite-spin (i.e. singlet) correlations.")
mp2_singles_energy: Optional[float] = Schema(
None, description="The singles portion of the MP2 correlation energy. Zero except in ROHF.")
mp2_doubles_energy: Optional[float] = Schema(
None,
description=
"The doubles portion of the MP2 correlation energy including same-spin and opposite-spin correlations.")
mp2_total_correlation_energy: Optional[float] = Schema(
None, description="The MP2 correlation energy.") # Old name, to be deprecated
mp2_correlation_energy: Optional[float] = Schema(None, description="The MP2 correlation energy.")
mp2_total_energy: Optional[float] = Schema(
None, description="The total MP2 energy (MP2 correlation energy + HF energy).")
mp2_dipole_moment: Optional[List[float]] = Schema(None, description="The MP2 X, Y, and Z dipole components.")
# CCSD Keywords
ccsd_same_spin_correlation_energy: Optional[float] = Schema(
None, description="The portion of CCSD doubles correlation energy from same-spin (i.e. triplet) correlations.")
ccsd_opposite_spin_correlation_energy: Optional[float] = Schema(
None,
description="The portion of CCSD doubles correlation energy from opposite-spin (i.e. singlet) correlations")
ccsd_singles_energy: Optional[float] = Schema(
None, description="The singles portion of the CCSD correlation energy. Zero except in ROHF.")
ccsd_doubles_energy: Optional[float] = Schema(
None,
description=
"The doubles portion of the CCSD correlation energy including same-spin and opposite-spin correlations.")
ccsd_correlation_energy: Optional[float] = Schema(None, description="The CCSD correlation energy.")
ccsd_total_energy: Optional[float] = Schema(
None, description="The total CCSD energy (CCSD correlation energy + HF energy).")
ccsd_dipole_moment: Optional[List[float]] = Schema(None, description="The CCSD X, Y, and Z dipole components.")
ccsd_iterations: Optional[int] = Schema(None,
description="The number of CCSD iterations taken before convergence.")
# CCSD(T) keywords
ccsd_prt_pr_correlation_energy: Optional[float] = Schema(None, description="The CCSD(T) correlation energy.")
ccsd_prt_pr_total_energy: Optional[float] = Schema(
None, description="The total CCSD(T) energy (CCSD(T) correlation energy + HF energy).")
ccsd_prt_pr_dipole_moment: Optional[List[float]] = Schema(None,
description="The CCSD(T) X, Y, and Z dipole components.")
class Config(ProtoModel.Config):
force_skip_defaults = True
def __str__(self):
data_str = ', '.join(f'{k}={v}' for k, v in self.dict().items())
return f"{self.__class__.__name__}({data_str})"
class CategoryBase(BaseModel):
"""商品分类"""
cat_keywords: str = Schema(None, max_length=255, title='分类关键词')
cat_desc: str = Schema(None, title='分类描述')
class Model(BaseModel):
a: int = Schema(3, const=True)
class MyModel(BaseModel):
a: str = Schema('default', alias='alias_a')
b: str = Schema('default', alias='alias_b')
class Config:
extra = 'allow'
class FacePropertiesAbridged(BaseModel):
type: Enum('FacePropertiesAbridged', {'type': 'FacePropertiesAbridged'})
energy: FaceEnergyPropertiesAbridged = Schema(default=None)
def __init__(
self,
path: str,
endpoint: Callable,
*,
response_model: Type[Any] = None,
status_code: int = 200,
tags: List[str] = None,
dependencies: Sequence[params.Depends] = None,
summary: str = None,
description: str = None,
response_description: str = "Successful Response",
responses: Dict[Union[int, str], Dict[str, Any]] = None,
deprecated: bool = None,
name: str = None,
methods: Optional[Union[Set[str], List[str]]] = None,
operation_id: str = None,
response_model_include: Union[SetIntStr, DictIntStrAny] = None,
response_model_exclude: Union[SetIntStr, DictIntStrAny] = set(),
response_model_by_alias: bool = True,
response_model_skip_defaults: bool = False,
include_in_schema: bool = True,
response_class: Optional[Type[Response]] = None,
dependency_overrides_provider: Any = None,
) -> None:
self.path = path
self.endpoint = endpoint
self.name = get_name(endpoint) if name is None else name
self.path_regex, self.path_format, self.param_convertors = compile_path(
path)
if methods is None:
methods = ["GET"]
self.methods = set([method.upper() for method in methods])
self.unique_id = generate_operation_id_for_path(
name=self.name, path=self.path_format, method=list(methods)[0])
self.response_model = response_model
if self.response_model:
response_name = "Response_" + self.unique_id
self.response_field: Optional[Field] = Field(
name=response_name,
type_=self.response_model,
class_validators={},
default=None,
required=False,
model_config=BaseConfig,
schema=Schema(None),
)
# Create a clone of the field, so that a Pydantic submodel is not returned
# as is just because it's an instance of a subclass of a more limited class
# e.g. UserInDB (containing hashed_password) could be a subclass of User
# that doesn't have the hashed_password. But because it's a subclass, it
# would pass the validation and be returned as is.
# By being a new field, no inheritance will be passed as is. A new model
# will be always created.
self.secure_cloned_response_field: Optional[
Field] = create_cloned_field(self.response_field)
else:
self.response_field = None
self.secure_cloned_response_field = None
self.status_code = status_code
self.tags = tags or []
if dependencies:
self.dependencies = list(dependencies)
else:
self.dependencies = []
self.summary = summary
self.description = description or inspect.cleandoc(
self.endpoint.__doc__ or "")
# if a "form feed" character (page break) is found in the description text,
# truncate description text to the content preceding the first "form feed"
self.description = self.description.split("\f")[0]
self.response_description = response_description
self.responses = responses or {}
response_fields = {}
for additional_status_code, response in self.responses.items():
assert isinstance(response,
dict), "An additional response must be a dict"
model = response.get("model")
if model:
assert lenient_issubclass(
model,
BaseModel), "A response model must be a Pydantic model"
response_name = f"Response_{additional_status_code}_{self.unique_id}"
response_field = Field(
name=response_name,
type_=model,
class_validators=None,
default=None,
required=False,
model_config=BaseConfig,
schema=Schema(None),
)
response_fields[additional_status_code] = response_field
if response_fields:
self.response_fields: Dict[Union[int, str],
Field] = response_fields
else:
self.response_fields = {}
self.deprecated = deprecated
self.operation_id = operation_id
self.response_model_include = response_model_include
self.response_model_exclude = response_model_exclude
self.response_model_by_alias = response_model_by_alias
self.response_model_skip_defaults = response_model_skip_defaults
self.include_in_schema = include_in_schema
self.response_class = response_class
assert inspect.isfunction(endpoint) or inspect.ismethod(
endpoint), f"An endpoint must be a function or method"
self.dependant = get_dependant(path=self.path_format,
call=self.endpoint)
for depends in self.dependencies[::-1]:
self.dependant.dependencies.insert(
0,
get_parameterless_sub_dependant(depends=depends,
path=self.path_format),
)
self.body_field = get_body_field(dependant=self.dependant,
name=self.unique_id)
self.dependency_overrides_provider = dependency_overrides_provider
self.app = request_response(self.get_route_handler())
class Model(BaseModel):
foo: int = Schema(4, alias='foofoo')
class Model(BaseModel):
foo: FooEnum
bar: BarEnum
spam: SpamEnum = Schema(None)
class Foo(BaseModel):
a: str = Schema('foo', examples=['bar'])
def test_schema_repr():
s = Schema(4, title='Foo is Great')
assert repr(s) == "Schema(default: 4, title: 'Foo is Great', extra: {})"
assert str(s) == "Schema(default: 4, title: 'Foo is Great', extra: {})"
class Foo(BaseModel):
a: type_ = Schema('foo',
title='A title',
description='A description',
**kwargs)
class Model(BaseModel):
foo: int = Schema(4, title='Foo is Great')
bar: str = Schema(..., description='this description of bar')
def batch_decorator(cls: MetaModel) -> MetaModel:
cls.__annotations__ = {arg_name: list for arg_name in model_args_names}
cls.__fields__ = {arg_name: Field(name=arg_name, type_=list, class_validators=None,
model_config=BaseConfig, required=False, schema=Schema(None))
for arg_name in model_args_names}
return cls
class DoorPropertiesAbridged(BaseModel):
type: Enum('DoorPropertiesAbridged', {'type': 'DoorPropertiesAbridged'})
energy: DoorEnergyPropertiesAbridged = Schema(default=None)
class Model(BaseModel):
a: str = Schema('some string', const=False)
class FaceEnergyPropertiesAbridged(BaseModel):
type: Enum('FaceEnergyPropertiesAbridged',
{'type': 'FaceEnergyPropertiesAbridged'})
construction: str = Schema(default=None, min_length=1, max_length=100)
class Shop(BaseModel):
id: int
name: str = Schema(..., description='shop name')
class ShadePropertiesAbridged(BaseModel):
type: Enum('ShadePropertiesAbridged', {'type': 'ShadePropertiesAbridged'})
energy: ShadeEnergyPropertiesAbridged = Schema(default=None)
class ShopWithItems(Shop):
items: List[Item] = Schema([], description='sale items in the shop')
class Pet(BaseModel):
pet_id: Optional[int] = Schema(..., alias='id')
name: str
age: int
class ItemWithDealingShop(Item):
shops: List[Shop] = Schema([], description='shops dealing with the item')
class MyModel(BaseModel):
a: str = Schema('default', alias='alias_a')
b: str = Schema('default', alias='alias_b')
class Config:
allow_population_by_alias = True
class Item(BaseModel):
id: int
name: str = Schema(..., description='item name')
price: int = Schema(..., description='item price')
class MyModel(BaseModel):
a: str = Schema(None, alias='alias_a')
class Config:
extra = Extra.allow
def __init__(
self,
path: str,
endpoint: Callable,
*,
response_model: Type[Any] = None,
status_code: int = 200,
tags: List[str] = None,
dependencies: List[params.Depends] = None,
summary: str = None,
description: str = None,
response_description: str = "Successful Response",
responses: Dict[Union[int, str], Dict[str, Any]] = None,
deprecated: bool = None,
name: str = None,
methods: List[str] = None,
operation_id: str = None,
response_model_include: Set[str] = None,
response_model_exclude: Set[str] = set(),
response_model_by_alias: bool = True,
response_model_skip_defaults: bool = False,
include_in_schema: bool = True,
response_class: Type[Response] = JSONResponse,
) -> None:
assert path.startswith("/"), "Routed paths must always start with '/'"
self.path = path
self.endpoint = endpoint
self.name = get_name(endpoint) if name is None else name
self.response_model = response_model
if self.response_model:
assert lenient_issubclass(
response_class, JSONResponse
), "To declare a type the response must be a JSON response"
response_name = "Response_" + self.name
self.response_field: Optional[Field] = Field(
name=response_name,
type_=self.response_model,
class_validators={},
default=None,
required=False,
model_config=BaseConfig,
schema=Schema(None),
)
else:
self.response_field = None
self.status_code = status_code
self.tags = tags or []
self.dependencies = dependencies or []
self.summary = summary
self.description = description or inspect.cleandoc(self.endpoint.__doc__ or "")
self.response_description = response_description
self.responses = responses or {}
response_fields = {}
for additional_status_code, response in self.responses.items():
assert isinstance(response, dict), "An additional response must be a dict"
model = response.get("model")
if model:
assert lenient_issubclass(
model, BaseModel
), "A response model must be a Pydantic model"
response_name = f"Response_{additional_status_code}_{self.name}"
response_field = Field(
name=response_name,
type_=model,
class_validators=None,
default=None,
required=False,
model_config=BaseConfig,
schema=Schema(None),
)
response_fields[additional_status_code] = response_field
if response_fields:
self.response_fields: Dict[Union[int, str], Field] = response_fields
else:
self.response_fields = {}
self.deprecated = deprecated
if methods is None:
methods = ["GET"]
self.methods = methods
self.operation_id = operation_id
self.response_model_include = response_model_include
self.response_model_exclude = response_model_exclude
self.response_model_by_alias = response_model_by_alias
self.response_model_skip_defaults = response_model_skip_defaults
self.include_in_schema = include_in_schema
self.response_class = response_class
self.path_regex, self.path_format, self.param_convertors = compile_path(path)
assert inspect.isfunction(endpoint) or inspect.ismethod(
endpoint
), f"An endpoint must be a function or method"
self.dependant = get_dependant(path=self.path_format, call=self.endpoint)
for depends in self.dependencies[::-1]:
self.dependant.dependencies.insert(
0,
get_parameterless_sub_dependant(depends=depends, path=self.path_format),
)
self.body_field = get_body_field(dependant=self.dependant, name=self.name)
self.app = request_response(
get_app(
dependant=self.dependant,
body_field=self.body_field,
status_code=self.status_code,
response_class=self.response_class,
response_field=self.response_field,
response_model_include=self.response_model_include,
response_model_exclude=self.response_model_exclude,
response_model_by_alias=self.response_model_by_alias,
response_model_skip_defaults=self.response_model_skip_defaults,
)
)
class CitizensPresentsCalendar(BaseModel):
m_1: List[CitizenGiftCounter] = Schema([], alias="1")
m_2: List[CitizenGiftCounter] = Schema([], alias="2")
m_3: List[CitizenGiftCounter] = Schema([], alias="3")
m_4: List[CitizenGiftCounter] = Schema([], alias="4")
m_5: List[CitizenGiftCounter] = Schema([], alias="5")
m_6: List[CitizenGiftCounter] = Schema([], alias="6")
m_7: List[CitizenGiftCounter] = Schema([], alias="7")
m_8: List[CitizenGiftCounter] = Schema([], alias="8")
m_9: List[CitizenGiftCounter] = Schema([], alias="9")
m_10: List[CitizenGiftCounter] = Schema([], alias="10")
m_11: List[CitizenGiftCounter] = Schema([], alias="11")
m_12: List[CitizenGiftCounter] = Schema([], alias="12")
class AperturePropertiesAbridged(BaseModel):
type: Enum('AperturePropertiesAbridged',
{'type': 'AperturePropertiesAbridged'})
energy: ApertureEnergyPropertiesAbridged = Schema(default=None)
class CategoryCreate(CategoryBase):
"""商品分类-创建"""
parent_id: int = Schema(..., ge=0, title='父分类, 0表示一级分类')
cat_name: str = Schema(..., max_length=64, title='分类名')
class Message(BotXType):
"""
A Message object, which was received from BotX
:param SyncID sync_id: Id of the message
"""
sync_id: SyncID
command: MessageCommand
file: Optional[File] = None
user: MessageUser = Schema(..., alias="from")
bot_id: UUID
def __init__(self, **data):
super().__init__(**data)
self.sync_id = SyncID(data["sync_id"])
@property
def body(self) -> str:
"""
The text of the message
:getter: Returns the text of the message
:type: str
"""
return self.command.body
@property
def data(self) -> Dict[str, Any]:
return self.command.data
@property
def user_huid(self) -> Optional[UUID]:
"""
The user_huid of the message
:getter: Returns the user_huid for the message
:type: UUID
"""
return self.user.user_huid
@property
def ad_login(self) -> Optional[str]:
"""
The ad_login of the message
:getter: Returns the ad_login for the message
:type: str
"""
return self.user.ad_login
@property
def group_chat_id(self) -> UUID:
"""
The group_chat_id of the message
:getter: Returns the group_chat_id of the message
:type: UUID
"""
return self.user.group_chat_id
@property
def chat_type(self) -> str:
"""
The chat_type of the message
:getter: Returns the chat_type of the message
:type: str
"""
return self.user.chat_type.name
@property
def host(self) -> str:
"""
The host of the message
:getter: Returns the host of the message
:type: str
"""
return self.user.host
