class Guild(Model):
guild_id = BigIntField(unique=True)
prefix = CharField(max_length=5, null=True, default="?")
clear_spam = BooleanField(default=False)
aggregate_clans = BooleanField(default=True)
track_sherpas = BooleanField(default=False)
admin_channel = BigIntField(unique=True, null=True)
announcement_channel = BigIntField(unique=True, null=True)
class MonsterDrop(Model):
item = ForeignKeyField("models.Item", related_name="drops")
monster = ForeignKeyField("models.Monster", related_name="drops")
rate = IntField()
pickpocket_only = BooleanField(default=False)
no_pickpocket = BooleanField(default=False)
conditional = BooleanField(default=False)
fixed = BooleanField(default=False)
stealable_accordion = BooleanField(default=False)
class Skill(Model, metaclass=SkillMeta):
id = IntField(pk=True, generated=False)
name = CharField(max_length=255)
image = CharField(max_length=255)
level_required = IntField(default=0)
mp_cost = IntField(default=0)
passive: bool = BooleanField(default=False) # type: ignore
noncombat: bool = BooleanField(default=False) # type: ignore
shruggable: bool = BooleanField(default=False) # type: ignore
combat: bool = BooleanField(default=False) # type: ignore
healing: bool = BooleanField(default=False) # type: ignore
summon: bool = BooleanField(default=False) # type: ignore
expression: bool = BooleanField(default=False) # type: ignore
walk: bool = BooleanField(default=False) # type: ignore
mutex_song: bool = BooleanField(default=False) # type: ignore
@property
def buff(self) -> bool:
return self.shruggable
def have(self):
return self in self.kol.state.skills
async def cast(self, times: int = 1):
return await request.skill_use(self.kol, self, times).parse()
class Role(Model):
role_id = BigIntField()
platform_id = IntField(null=True)
is_sherpa = BooleanField(null=True)
is_clanmember = BooleanField(null=True)
is_new_clanmember = BooleanField(null=True)
is_non_clanmember = BooleanField(null=True)
is_protected_clanmember = BooleanField(null=True)
guild: ForeignKeyRelation[Guild] = ForeignKeyField(
"seraphsix.Guild", related_name="roles", to_field="id"
)
class Meta:
indexes = ("guild", "role_id")
class ClanMember(Model):
platform_id = IntField()
join_date = DatetimeField()
is_active = BooleanField(default=True)
last_active = DatetimeField(null=True)
is_sherpa = BooleanField(default=False)
member_type = IntField(null=True, validators=[ClanMemberRankValidator()])
clan: ForeignKeyRelation[Clan] = ForeignKeyField(
"seraphsix.Clan", related_name="members", to_field="id"
)
member: ForeignKeyRelation[Member] = ForeignKeyField(
"seraphsix.Member", related_name="clans", to_field="id"
)
class User(Model):
id = IntField(pk=True)
name = CharField(max_length=255, unique=True)
password = TextField(null=True)
given_name = TextField(null=True)
family_name = TextField(null=True)
email = TextField(null=True)
realm = TextField()
realmuid = TextField(null=True)
active = BooleanField()
time_created = DatetimeField(auto_now_add=True)
time_updated = DatetimeField(auto_now=True)
groups = ManyToManyField('models.Group', related_name='users')
class Clan(Model):
clan_id = BigIntField(unique=True)
name = CharField(max_length=255)
callsign = CharField(max_length=4)
platform = IntField(null=True, validators=[PlatformValidator()])
the100_group_id = IntField(unique=True, null=True)
activity_tracking = BooleanField(default=True)
guild: ForeignKeyRelation[Guild] = ForeignKeyField(
"seraphsix.Guild", related_name="clans", to_field="id"
)
members: ReverseRelation["ClanMember"]
class Guild(Model):
id = BigIntField(pk=True)
prefix = TextField(null=True)
mute_role = BigIntField(null=True)
level_up_messages = BooleanField(default=True)
moderators: ReverseRelation["Moderator"]
mutes: ReverseRelation["Mute"]
warns: ReverseRelation["Warn"]
class Meta:
table = "guilds"
def __str__(self):
return f"<Guild id:{self.id} prefix:{self.prefix} muterole:{self.mute_role}>"
class GameMember(Model):
time_played = FloatField(null=True)
completed = BooleanField(null=True)
member: ForeignKeyRelation[Member] = ForeignKeyField(
"seraphsix.Member", related_name="games", to_field="id"
)
game: ForeignKeyRelation[Game] = ForeignKeyField(
"seraphsix.Game", related_name="members", to_field="id"
)
class Meta:
indexes = ("member", "game")
class ClanMemberApplication(Model):
approved = BooleanField(default=False)
message_id = BigIntField(unique=True)
guild: ForeignKeyRelation[Guild] = ForeignKeyField(
"seraphsix.Guild", related_name="clanmemberapplications", to_field="id"
)
member: ForeignKeyRelation[Member] = ForeignKeyField(
"seraphsix.Member", related_name="clanmemberapplications_created", to_field="id"
)
approved_by: ForeignKeyRelation[Member] = ForeignKeyField(
"seraphsix.Member",
related_name="clanmemberapplications_approved",
to_field="id",
)
class Mute(Model):
id = IntField(pk=True)
moderator = BigIntField()
reason = TextField(null=True)
start = DatetimeField(auto_now_add=True)
end = DatetimeField()
active = BooleanField(default=True)
user: ForeignKeyRelation[User] = ForeignKeyField("models.User",
related_name="mutes")
guild: ForeignKeyRelation[Guild] = ForeignKeyField("models.Guild",
related_name="mutes")
class Meta:
table = "mutes"
def __str__(self):
return (
f"<Mute id:{self.id} moderator:{self.moderator} "
f"reason:'{self.reason}' start:{self.start} end:{self.end} "
f"active:{self.active} user:{self.user.id} guild:{self.guild.id}>")
class Member(Model):
discord_id = BigIntField(null=True)
bungie_id = BigIntField(null=True)
bungie_username = CharField(max_length=255, null=True)
xbox_id = BigIntField(null=True)
xbox_username = CharField(max_length=255, unique=True, null=True)
psn_id = BigIntField(null=True)
psn_username = CharField(max_length=255, unique=True, null=True)
blizzard_id = BigIntField(null=True)
blizzard_username = CharField(max_length=255, unique=True, null=True)
steam_id = BigIntField(null=True)
steam_username = CharField(max_length=255, unique=True, null=True)
stadia_id = BigIntField(null=True)
stadia_username = CharField(max_length=255, unique=True, null=True)
the100_id = BigIntField(unique=True, null=True)
the100_username = CharField(max_length=255, unique=True, null=True)
timezone = CharField(max_length=255, null=True)
bungie_access_token = CharField(max_length=360, unique=True, null=True)
bungie_refresh_token = CharField(max_length=360, unique=True, null=True)
is_cross_save = BooleanField(default=False)
primary_membership_id = BigIntField(unique=True, null=True)
clan: ReverseRelation["ClanMember"]
games: ReverseRelation["GameMember"]
class Meta:
indexes = [
PostgreSQLIndex(
fields={
"discord_id",
"bungie_id",
"xbox_id",
"psn_id",
"blizzard_id",
"steam_id",
"stadia_id",
"the100_id",
}
)
]
class Item(Model, metaclass=ItemMeta):
id: int = IntField(pk=True, generated=False) # type: ignore
name: str = CharField(max_length=255) # type: ignore
desc_id: int = IntField() # type: ignore
plural: str = CharField(max_length=255, null=True) # type: ignore
image: str = CharField(max_length=255) # type: ignore
autosell_value: int = IntField(default=0) # type: ignore
level_required: int = IntField(default=0) # type: ignore
# Consumables
food: bool = BooleanField(default=False) # type: ignore
fullness: int = IntField(default=0) # type: ignore
booze: bool = BooleanField(default=False) # type: ignore
inebriety: int = IntField(default=0) # type: ignore
spleen: bool = BooleanField(default=False) # type: ignore
spleenhit: int = IntField(default=0) # type: ignore
quality: str = CharField(max_length=255, null=True) # type: ignore
gained_adventures_min: int = IntField(default=0) # type: ignore
gained_adventures_max: int = IntField(default=0) # type: ignore
gained_muscle_min: int = IntField(default=0) # type: ignore
gained_muscle_max: int = IntField(default=0) # type: ignore
gained_mysticality_min: int = IntField(default=0) # type: ignore
gained_mysticality_max: int = IntField(default=0) # type: ignore
gained_moxie_min: int = IntField(default=0) # type: ignore
gained_moxie_max: int = IntField(default=0) # type: ignore
# Usability
usable: bool = BooleanField(default=False) # type: ignore
multiusable: bool = BooleanField(default=False) # type: ignore
combat_usable: bool = BooleanField(default=False) # type: ignore
reusable: bool = BooleanField(default=False) # type: ignore
combat_reusable: bool = BooleanField(default=False) # type: ignore
# Can be used on others
curse: bool = BooleanField(default=False) # type: ignore
# Equipment
hat: bool = BooleanField(default=False) # type: ignore
pants: bool = BooleanField(default=False) # type: ignore
shirt: bool = BooleanField(default=False) # type: ignore
weapon: bool = BooleanField(default=False) # type: ignore
weapon_hands: Optional[int] = IntField(null=True) # type: ignore
weapon_type: Optional[str] = CharField(max_length=255,
null=True) # type: ignore
offhand: bool = BooleanField(default=False) # type: ignore
offhand_type: Optional[str] = CharField(max_length=255,
null=True) # type: ignore
accessory: bool = BooleanField(default=False) # type: ignore
container: bool = BooleanField(default=False) # type: ignore
sixgun: bool = BooleanField(default=False) # type: ignore
familiar_equipment: bool = BooleanField(default=False) # type: ignore
power: Optional[int] = IntField(null=True) # type: ignore
required_muscle: int = IntField(default=0) # type: ignore
required_mysticality: int = IntField(default=0) # type: ignore
required_moxie: int = IntField(default=0) # type: ignore
required_class: Optional[CharacterClass] = EnumField(
enum_type=CharacterClass, null=True) # type: ignore
notes: str = CharField(max_length=255, default="") # type: ignore
# Collections
foldgroup: Optional["libkol.FoldGroup"] = ForeignKeyField(
"models.FoldGroup", related_name="items", null=True) # type: ignore
foldgroup_id: Optional[int]
zapgroup: Optional["libkol.ZapGroup"] = ForeignKeyField(
"models.ZapGroup", related_name="items", null=True) # type: ignore
zapgroup_id: Optional[int]
outfit_variants = ManyToManyField("models.OutfitVariant",
related_name="pieces",
null=True)
# NPC Store Info
store_row: Optional[int] = IntField(null=True) # type: ignore
store_price: Optional[int] = IntField(null=True) # type: ignore
store: Optional["libkol.Store"] = ForeignKeyField(
"models.Store", related_name="items", null=True) # type: ignore
store_id: Optional[int]
# Flags
hatchling: bool = BooleanField(default=False) # type: ignore
pokepill: bool = BooleanField(default=False) # type: ignore
sticker: bool = BooleanField(default=False) # type: ignore
card: bool = BooleanField(default=False) # type: ignore
folder: bool = BooleanField(default=False) # type: ignore
bootspur: bool = BooleanField(default=False) # type: ignore
bootskin: bool = BooleanField(default=False) # type: ignore
food_helper: bool = BooleanField(default=False) # type: ignore
booze_helper: bool = BooleanField(default=False) # type: ignore
guardian: bool = BooleanField(default=False) # type: ignore
single_equip: bool = BooleanField(default=True) # type: ignore
# Can appear as a bounty item
bounty: bool = BooleanField(default=False) # type: ignore
# 0: n/a, 1: simple, 2: complex
candy: int = IntField() # type: ignore
# What is this for?
sphere: bool = BooleanField(default=False) # type: ignore
# is a quest item
quest: bool = BooleanField(default=False) # type: ignore
# is a gift item
gift: bool = BooleanField(default=False) # type: ignore
# is tradeable
tradeable: bool = BooleanField(default=False) # type: ignore
# is discardable
discardable: bool = BooleanField(default=False) # type: ignore
# is considered salad when consumed
salad: bool = BooleanField(default=False) # type: ignore
# is considered beer when consumed
beer: bool = BooleanField(default=False) # type: ignore
# is considered wine when consumed
wine: bool = BooleanField(default=False) # type: ignore
# is considered martini when consumed
martini: bool = BooleanField(default=False) # type: ignore
# is considered saucy when consumed
saucy: bool = BooleanField(default=False) # type: ignore
# is considered lasagna when consumed
lasagna: bool = BooleanField(default=False) # type: ignore
# is considered pasta when consumed
pasta: bool = BooleanField(default=False) # type: ignore
@property
def adventures(self):
return (self.gained_adventures_min + self.gained_adventures_max) / 2
def pluralize(self):
return "{}s".format(self.name) if self.plural is None else self.plural
@property
def space(self):
s = (self.fullness if self.food else self.inebriety
if self.booze else self.spleenhit if self.spleen else None)
if s is None:
raise WrongKindOfItemError("You cannot consume this item")
return s
async def autosell(self, quantity: int = 1):
return await request.autosell_items(self.kol, [self]).parse()
@property
def cleans_organ(self) -> Optional[Tuple[int, str]]:
m = re.match(r"-(\d+) spleen", self.notes)
if m is None:
return None
return (int(m.group(1)), "spleen")
async def consume(self,
utensil: Optional["Item"] = None
) -> parsing.ResourceGain:
if self.food:
return await request.eat(self.kol, self, utensil=utensil).parse()
elif self.booze:
return await request.drink(self.kol, self, utensil=utensil).parse()
elif self.spleen:
return await request.chew(self.kol, self).parse()
else:
raise WrongKindOfItemError("You cannot consume this item")
@classmethod
async def get_or_discover(cls, *args, **kwargs) -> "Item":
result = await cls.filter(*args, **kwargs).first()
if result is None:
id: int = kwargs.get("id", None)
desc_id: int = kwargs.get("desc_id", None)
return await cls.discover(id=id, desc_id=desc_id)
return result
@classmethod
async def discover(cls, id: int = None, desc_id: int = None):
"""
Discover this item using its id or description id. The description id is preferred as
it provides more information, so if only an id is provided, libkol will first determine
the desc_id.
Note that this Returns an Item object but it is not automatically committed to the database.
:param id: Id of the item to discover
:param desc_id: Description id of the item to discover
"""
if id is not None:
desc_id = (await request.item_information(cls.kol,
id).parse()).descid
if desc_id is None:
raise ItemNotFoundError(
"Cannot discover an item without either an id or a desc_id")
info = await request.item_description(cls.kol, desc_id).parse()
return Item(**{k: v for k, v in info.items() if v is not None})
@property
def type(self):
types = [
"hat",
"shirt",
"weapon",
"offhand",
"pants",
"familiar_equipment",
"accessory",
]
return next((t for t in types if getattr(self, t)), "other")
@property
def slot(self) -> Optional[Slot]:
return Slot.from_db(self.type)
async def get_description(self):
return await request.item_description(self.kol, self.desc_id).parse()
async def get_mall_price(self, limited: bool = False) -> Optional[int]:
"""
Get the lowest price for this item in the mall
:param limited: Include limited sales in this search
"""
prices = await request.mall_price(self.kol, self).parse()
if limited and len(prices.limited) > 0:
return prices.limited[0].price
if len(prices.unlimited) > 0:
return prices.unlimited[0].price
return None
async def get_cf_price(self, days: int = 30) -> Optional[int]:
"""
Get the average transaction price from Coldfront logs
:param days: Number of days of transactions to consider (default 30)
"""
ts = int(time.time())
params = {
"itemid": self.id,
"starttime": ts - 60 * 68 * 24 * days,
"endtime": ts,
}
response = await self.kol.request(
"http://kol.coldfront.net/newmarket/translist.php",
"GET",
params=params)
result = await response.text()
transactions = [
parsing.to_float(t[(t.rfind("@") + 1):])
for t in result[result.find("\n"):].split("\n")
if t not in ["", "."]
]
return int(mean(transactions)) if len(transactions) > 0 else None
async def get_mall_listings(self, **kwargs) -> List["types.Listing"]:
return await request.mall_search(self.kol, query=self,
**kwargs).parse()
async def buy_from_mall(
self,
listing: "types.Listing" = None,
store_id: int = None,
price: int = 0,
quantity: int = 1,
):
if listing is None and store_id is None:
listings = await self.get_mall_listings(num_results=quantity,
max_price=price)
tasks = [] # type: List[Coroutine]
for l in listings:
q = min(quantity, (l.limit if l.limit > 0 else quantity),
l.stock)
tasks += [
request.mall_purchase(self.kol,
item=self,
listing=l,
quantity=q).parse()
]
quantity -= q
return await asyncio.gather(*tasks)
return await request.mall_purchase(
self.kol,
item=self,
listing=listing,
store_id=store_id,
price=price,
quantity=quantity,
).parse()
async def acquire(self, quantity: int = 1):
need = quantity - self.amount
if need > 0:
await self.buy_from_mall(quantity=need)
return True
@property
def amount(self):
return self.kol.inventory[self] + list(
self.kol.equipment.values()).count(self)
def equipped(self):
return self in self.kol.equipment.values()
async def equip(self, slot: Optional[Slot] = None) -> bool:
actual_slot = self.slot if slot is None else slot
if actual_slot is None:
raise WrongKindOfItemError("This item cannot be equipped")
curr = self.kol.equipment
# If it's already there don't worry
if curr[actual_slot] == self:
return True
# If user didn't specify an accessory and we have it in a slot, don't worry
if (actual_slot is Slot.Acc1 and slot is None
and (curr[Slot.Acc2] == self or curr[Slot.Acc3] == self)):
return True
return await request.equip(self.kol, self, actual_slot).parse()
def have(self):
return self.amount > 0
def meet_requirements(self):
return (self.kol.level >= self.level_required
and self.kol.get_stat(Stat.Muscle) >= self.required_muscle
and self.kol.get_stat(
Stat.Mysticality) >= self.required_mysticality
and self.kol.get_stat(Stat.Moxie) >= self.required_moxie)
async def use(self, quantity: int = 1, multi_use: bool = True):
if self.usable is False:
raise WrongKindOfItemError("This item cannot be used")
if self.multiusable and multi_use and quantity > 1:
await request.item_multi_use(self.kol, self, quantity).parse()
return
tasks = [
request.item_use(self.kol, self).parse() for _ in range(quantity)
]
return await asyncio.gather(*tasks)
class Bonus(Model):
item: Optional["libkol.Item"] = ForeignKeyField("models.Item",
related_name="bonuses",
null=True) # type: ignore
item_id: Optional[int]
effect: Optional["libkol.Effect"] = ForeignKeyField(
"models.Effect", related_name="bonuses", null=True) # type: ignore
effect_id: Optional[int]
outfit: Optional["libkol.Outfit"] = ForeignKeyField(
"models.Outfit", related_name="bonuses", null=True) # type: ignore
outfit_id: Optional[int]
familiar: Optional["libkol.Familiar"] = ForeignKeyField(
"models.Familiar", related_name="passive_bonuses",
null=True) # type: ignore
familiar_id: Optional[int]
throne_familiar: Optional["libkol.Familiar"] = ForeignKeyField(
"models.Familiar", related_name="throne_bonus",
null=True) # type: ignore
throne_familiar_id: Optional[int]
modifier: Modifier = EnumField(enum_type=Modifier) # type: ignore
numeric_value: Optional[int] = IntField(null=True) # type: ignore
string_value: str = CharField(max_length=255, null=True) # type: ignore
percentage: bool = BooleanField(default=False) # type: ignore
expression_value: Optional[str] = PickleField(null=True) # type: ignore
async def get_value(
self,
normalise: bool = False,
smithsness: Optional[int] = None,
familiar_weight: Optional[int] = None,
hobo_power: Optional[int] = None,
):
kol = self.kol
if self.string_value:
return 1
if self.numeric_value:
if self.percentage is False:
return self.numeric_value
return self.modifier.apply_percentage(kol,
self.numeric_value / 100)
if self.expression_value:
subs = {}
if familiar_weight is not None:
subs["W"] = familiar_weight
if smithsness is not None:
subs["K"] = smithsness
if hobo_power is not None:
subs["H"] = hobo_power
return await expression.evaluate(kol, self.expression_value, subs)
return 0
class User(BaseModel):
"""User Model"""
FIRST_NAME_LENGHT = 20
LOGIN_LENGHT = 20
LAST_NAME_LENGHT = 20
EMAIL_LENGHT = 60
login = CharField(LOGIN_LENGHT,
unique=True,
description="The login name of the user.")
first_name = CharField(FIRST_NAME_LENGHT, null=True)
last_name = CharField(LAST_NAME_LENGHT, null=True)
email = CharField(EMAIL_LENGHT, null=True)
is_active = BooleanField(null=True, default=False)
is_verified = BooleanField(null=True, default=False)
verified_at = DatetimeField(null=True)
password_hash = CharField(256, null=True)
last_login_at = DatetimeField(null=True)
roles = ManyToManyField("model.Role",
related_name="users",
through="user_roles")
class Meta:
# pylint: disable=too-few-public-methods
# pylint: disable=missing-docstring
table = "user"
ordering = ["login", "last_name", "first_name"]
class PydanticMeta:
include = (
"id",
"login",
"last_login_at",
"first_name",
"last_name",
"verified_at",
"created_at",
)
def __str__(self):
return "User"
@property
def password(self):
"""
Reading the password is forbidden.
"""
raise EnvironmentError()
@property
def is_password_set(self):
"""
Checks, if the password has been set.
"""
return self.password_hash is not None
@password.setter
def password(self, password):
"""Hash a password for storing."""
self.password_hash = generate_password_hash(password)
def verify_password(self, password: str) -> None:
"""
Generate a hashed password and compere it with the
stored password hash.
"""
if not self.is_password_set:
return False
return check_password_hash(self.password_hash, password)