class Some(Document):
citizenship = fields.StrField() # Гражданство
destination_country = fields.StrField() # Страна назначения
document = fields.StrField() # Необходимый документ
fields_groups = fields.ListField(fields.DictField())
fields = fields.ListField(fields.DictField())
class MyDoc(Document):
e = fields.EmbeddedField(MyEmbeddedDocument)
li = fields.ListField(fields.EmbeddedField(MyEmbeddedDocument))
b = fields.IntField(required=True)
class MySchema(BaseSchema):
d_list = fields.ListField(fields.IntField(), default=(1, 2, 3))
c_list = fields.ListField(fields.IntField(),
default=lambda: (1, 2, 3))
class NestedDoc(EmbeddedDocument):
simple = fields.StrField()
listed = fields.ListField(fields.StrField())
class Doc(Document):
nested = fields.EmbeddedField(NestedDoc)
listed = fields.ListField(fields.EmbeddedField(NestedDoc))
class Meta:
indexes = ['nested', 'nested.simple', 'listed', 'listed.simple', 'listed.listed']
class MyDoc(Document):
embedded = fields.EmbeddedField(MyEmbedded)
embedded_required = fields.EmbeddedField(MyEmbedded, required=True)
embedded_list = fields.ListField(fields.EmbeddedField(MyEmbedded))
embedded_dict = fields.DictField(
values=fields.EmbeddedField(MyEmbedded))
class MySchema(Schema):
list = fields.ListField(fields.IntField(),
attribute='in_mongo_list')
class Book(Document):
title = fields.StrField(attribute='t')
author = fields.EmbeddedField(Author, attribute='a')
chapters = fields.ListField(fields.EmbeddedField(Chapter),
attribute='c')
class PokemonBase(MixinDocument):
class Meta:
strict = False
abstract = True
id = fields.ObjectIdField(attribute="_id")
timestamp = fields.DateTimeField(default=datetime.utcnow)
owner_id = fields.IntegerField(required=True)
idx = fields.IntegerField(required=True)
species_id = fields.IntegerField(required=True)
level = fields.IntegerField(required=True)
xp = fields.IntegerField(required=True)
nature = fields.StringField(required=True)
iv_hp = fields.IntegerField(required=True)
iv_atk = fields.IntegerField(required=True)
iv_defn = fields.IntegerField(required=True)
iv_satk = fields.IntegerField(required=True)
iv_sdef = fields.IntegerField(required=True)
iv_spd = fields.IntegerField(required=True)
nickname = fields.StringField(default=None)
favorite = fields.BooleanField(default=False)
shiny = fields.BooleanField(required=True)
held_item = fields.IntegerField(default=None)
moves = fields.ListField(fields.IntegerField, default=list)
_hp = None
ailments = None
stages = None
@classmethod
def random(cls, **kwargs):
return cls(
iv_hp=random_iv(),
iv_atk=random_iv(),
iv_defn=random_iv(),
iv_satk=random_iv(),
iv_sdef=random_iv(),
iv_spd=random_iv(),
nature=random_nature(),
shiny=random.randint(1, 4096) == 1,
**kwargs,
)
@property
def species(self):
return self.bot.data.species_by_number(self.species_id)
@property
def max_xp(self):
return 250 + 25 * self.level
@property
def max_hp(self):
if self.species_id == 292:
return 1
return ((2 * self.species.base_stats.hp + self.iv_hp + 5) *
self.level // 100 + self.level + 10)
@property
def hp(self):
if self._hp is None:
return self.max_hp
return self._hp
@hp.setter
def hp(self, value):
self._hp = value
@property
def atk(self):
return math.floor(
((2 * self.species.base_stats.atk + self.iv_atk + 5) *
self.level // 100 + 5) *
constants.NATURE_MULTIPLIERS[self.nature]["atk"])
@property
def defn(self):
return math.floor(
((2 * self.species.base_stats.defn + self.iv_defn + 5) *
self.level // 100 + 5) *
constants.NATURE_MULTIPLIERS[self.nature]["defn"])
@property
def satk(self):
return math.floor(
((2 * self.species.base_stats.satk + self.iv_satk + 5) *
self.level // 100 + 5) *
constants.NATURE_MULTIPLIERS[self.nature]["satk"])
@property
def sdef(self):
return math.floor(
((2 * self.species.base_stats.sdef + self.iv_sdef + 5) *
self.level // 100 + 5) *
constants.NATURE_MULTIPLIERS[self.nature]["sdef"])
@property
def spd(self):
return math.floor(
((2 * self.species.base_stats.spd + self.iv_spd + 5) *
self.level // 100 + 5) *
constants.NATURE_MULTIPLIERS[self.nature]["spd"])
@property
def iv_percentage(self):
return (self.iv_hp / 31 + self.iv_atk / 31 + self.iv_defn / 31 +
self.iv_satk / 31 + self.iv_sdef / 31 + self.iv_spd / 31) / 6
def get_next_evolution(self, is_day):
if self.species.evolution_to is None or self.held_item == 13001:
return None
possible = []
for evo in self.species.evolution_to.items:
if not isinstance(evo.trigger, models.LevelTrigger):
continue
can = True
if evo.trigger.level and self.level < evo.trigger.level:
can = False
if evo.trigger.item and self.held_item != evo.trigger.item_id:
can = False
if evo.trigger.move_id and evo.trigger.move_id not in self.moves:
can = False
if evo.trigger.move_type_id and not any([
self.bot.data.move_by_number(x).type_id
== evo.trigger.move_type_id for x in self.moves
]):
can = False
if (evo.trigger.time == "day" and not is_day
or evo.trigger.time == "night" and is_day):
can = False
if evo.trigger.relative_stats == 1 and self.atk <= self.defn:
can = False
if evo.trigger.relative_stats == -1 and self.defn <= self.atk:
can = False
if evo.trigger.relative_stats == 0 and self.atk != self.defn:
can = False
if can:
possible.append(evo.target)
if len(possible) == 0:
return None
return random.choice(possible)
def can_evolve(self, ctx):
return self.get_next_evolution() is not None
class IOStudent(Student):
io_field = fields.ListField(
fields.IntField(io_validate=io_validate), allow_none=True)
class MySchema(BaseSchema):
a = fields.ListField(fields.IntField())
b = fields.ListField(fields.IntField(), attribute='in_mongo_b')
class Order(Document):
order = fields.IntegerField(required=True, unique=True)
products = fields.ListField(fields.ReferenceField(Product))
user_id = fields.IntegerField(required=True, unique=True)
order_time = fields.DateTimeField()
deletion_time = fields.DateTimeField()
class MySchema(EmbeddedSchema):
a = fields.EmbeddedField(MyEmbedded)
b = fields.ListField(fields.IntField)
class MySchema(EmbeddedSchema):
# EmbeddedField need instance to retrieve implementation
listed = fields.ListField(
fields.EmbeddedField(MyEmbedded, instance=self.instance))
embedded = fields.EmbeddedField(MyEmbedded, instance=self.instance)
required = fields.IntField(required=True)
class Bag(Document):
id = fields.EmbeddedField(Accessory,
attribute='_id',
required=True)
content = fields.ListField(fields.EmbeddedField(Accessory))
class MySchema(EmbeddedSchema):
# EmbeddedField need instance to retrieve implementation
a = fields.EmbeddedField(MyEmbedded, instance=self.instance)
b = fields.ListField(fields.IntField)
class Bag(MyDocument):
item = fields.EmbeddedField(Accessory)
content = fields.ListField(fields.EmbeddedField(Accessory))
class PokemonBase(MixinDocument):
class Meta:
strict = False
abstract = True
# General
id = fields.ObjectIdField(attribute="_id")
timestamp = fields.DateTimeField(default=datetime.utcnow)
owner_id = fields.IntegerField(required=True)
idx = fields.IntegerField(required=True)
# Details
species_id = fields.IntegerField(required=True)
level = fields.IntegerField(required=True)
xp = fields.IntegerField(required=True)
nature = fields.StringField(required=True)
shiny = fields.BooleanField(required=True)
# Stats
iv_hp = fields.IntegerField(required=True)
iv_atk = fields.IntegerField(required=True)
iv_defn = fields.IntegerField(required=True)
iv_satk = fields.IntegerField(required=True)
iv_sdef = fields.IntegerField(required=True)
iv_spd = fields.IntegerField(required=True)
iv_total = fields.IntegerField(required=False)
# Customization
nickname = fields.StringField(default=None)
favorite = fields.BooleanField(default=False)
held_item = fields.IntegerField(default=None)
moves = fields.ListField(fields.IntegerField, default=list)
has_color = fields.BooleanField(default=False)
color = fields.IntegerField(default=None)
_hp = None
ailments = None
stages = None
def __format__(self, spec):
if self.shiny:
name = "✨ "
else:
name = ""
if "l" in spec:
name += f"Level {self.level} "
elif "L" in spec:
name += f"L{self.level} "
if "p" in spec:
name += f"{self.iv_percentage:.2%} "
if self.bot.sprites.status and "i" in spec:
sprite = self.bot.sprites.get(self.species.dex_number,
shiny=self.shiny)
name = sprite + " " + name
name += str(self.species)
if self.nickname is not None and "n" in spec:
name += ' "' + self.nickname + '"'
if self.favorite and "f" in spec:
name += " ❤️"
return name
def __str__(self):
return f"{self}"
@classmethod
def random(cls, **kwargs):
ivs = [random_iv() for i in range(6)]
return cls(
iv_hp=ivs[0],
iv_atk=ivs[1],
iv_defn=ivs[2],
iv_satk=ivs[3],
iv_sdef=ivs[4],
iv_spd=ivs[5],
iv_total=sum(ivs),
nature=random_nature(),
shiny=random.randint(1, 4096) == 1,
**kwargs,
)
@property
def species(self):
return self.bot.data.species_by_number(self.species_id)
@property
def max_xp(self):
return 250 + 25 * self.level
@property
def max_hp(self):
if self.species_id == 292:
return 1
return ((2 * self.species.base_stats.hp + self.iv_hp + 5) *
self.level // 100 + self.level + 10)
@property
def hp(self):
if self._hp is None:
return self.max_hp
return self._hp
@hp.setter
def hp(self, value):
self._hp = value
@property
def atk(self):
return calc_stat(self, "atk")
@property
def defn(self):
return calc_stat(self, "defn")
@property
def satk(self):
return calc_stat(self, "satk")
@property
def sdef(self):
return calc_stat(self, "sdef")
@property
def spd(self):
return calc_stat(self, "spd")
@property
def iv_percentage(self):
return (self.iv_hp / 31 + self.iv_atk / 31 + self.iv_defn / 31 +
self.iv_satk / 31 + self.iv_sdef / 31 + self.iv_spd / 31) / 6
def get_next_evolution(self, is_day):
if self.species.evolution_to is None or self.held_item == 13001:
return None
possible = []
for evo in self.species.evolution_to.items:
if not isinstance(evo.trigger, models.LevelTrigger):
continue
can = True
if evo.trigger.level and self.level < evo.trigger.level:
can = False
if evo.trigger.item and self.held_item != evo.trigger.item_id:
can = False
if evo.trigger.move_id and evo.trigger.move_id not in self.moves:
can = False
if evo.trigger.move_type_id and not any([
self.bot.data.move_by_number(x).type_id
== evo.trigger.move_type_id for x in self.moves
]):
can = False
if evo.trigger.time == "day" and not is_day or evo.trigger.time == "night" and is_day:
can = False
if evo.trigger.relative_stats == 1 and self.atk <= self.defn:
can = False
if evo.trigger.relative_stats == -1 and self.defn <= self.atk:
can = False
if evo.trigger.relative_stats == 0 and self.atk != self.defn:
can = False
if can:
possible.append(evo.target)
if len(possible) == 0:
return None
return random.choice(possible)
def can_evolve(self, ctx):
return self.get_next_evolution() is not None
class Student(Document):
name = fields.StrField(required=True)
birthday = fields.DateTimeField()
courses = fields.ListField(fields.ReferenceField(Course))
class MyDoc(Document):
embedded_list = fields.ListField(fields.EmbeddedField(MyEmbedded),
allow_none=True)
embedded_dict = fields.DictField(
values=fields.EmbeddedField(MyEmbedded), allow_none=True)
embedded = fields.EmbeddedField(MyEmbedded, allow_none=True)
class Areal(EmbeddedDocument, metaclass=MetaBaseTemplate):
country = fields.StringField(required=True)
cities = fields.ListField(fields.StringField, missing=list)
geo = fields.ListField(fields.DictField)
class MySchema(BaseSchema):
list = fields.ListField(fields.IntField(),
attribute='in_mongo_list',
allow_none=True)
class IOStudent(Student):
io_field = fields.StrField(io_validate=io_validate)
list_io_field = fields.ListField(fields.IntField(io_validate=io_validate))
reference_io_field = fields.ReferenceField(
classroom_model.Course, io_validate=io_validate)
embedded_io_field = fields.EmbeddedField(EmbeddedDoc, io_validate=io_validate)
class MyDoc(Document):
embeds = fields.ListField(fields.EmbeddedField(MyEmbeddedDocument))
refs = fields.ListField(fields.ReferenceField(ToRefDoc))
class Team(Document):
name = fields.StrField(attribute='n')
leader = fields.EmbeddedField(Person, attribute='l')
sponsors = fields.ListField(fields.EmbeddedField(Company),
attribute='s')
class IOStudent(Student):
io_field = fields.ListField(
fields.IntField(io_validate=io_validate))
class UserInChat(umongo.Document): # noqa
"""
User in some chat.
"""
user: User = fields.ReferenceField(
User) # reference to main data about user
chat: Chat = fields.ReferenceField(Chat) # reference to current chat
roles = fields.ListField(fields.ObjectIdField, default=[])
warns: int = fields.IntegerField(default=0)
join_date: int = fields.IntegerField(default=time.time)
@staticmethod
async def create_user(user: User,
chat: Chat,
roles_: typing.List[Role] = None,
join_date: int = None):
"""
Create user in database
"""
if join_date is None:
join_date = time.time()
if roles_ is None:
roles = []
else:
roles = [role.pk for role in roles_]
usr = UserInChat(user=user,
chat=chat,
roles=roles,
join_date=join_date)
await usr.commit()
return usr
@staticmethod
async def add_role(user: "******", role: str):
"""
:param user:
:param role: '_id' of object
:return:
"""
current = user.dump()
roles: list = current["roles"]
roles.append(role)
user.update({"roles": roles})
return await user.commit()
@staticmethod
async def get_user(chat: str, user: str):
"""
Get user via chat '_id' and user '_id'
:param chat: _id of chat
:param user: _id of user
:return:
"""
usr = await UserInChat.find_one({"chat": chat, "user": user})
return usr
def get_roles(self) -> typing.AsyncGenerator[dict, None]:
"""
Get user roles; Returns a async generator.
:return:
"""
roles = instance.db.role.aggregate([
{
"$match": {
"_id": {
"$in": self.roles
}
}
},
{
"$addFields": {
"_order": {
"$indexOfArray": [self.roles, "$_id"]
}
}
},
{
"$sort": {
"_order": 1
}
},
])
return roles
async def permissions(self,
roles: typing.AsyncGenerator[dict, None] = None):
"""
Get user permissions
:return:
"""
if roles is None:
roles = self.get_roles()
permissions = DEFAULT_PERMISSIONS.copy()
async for role in roles:
permissions.update(role["permissions"])
return permissions
class Meta:
collection = instance.db.users_in_chats
