`lgrez.bdd` (Gestion des données)¶

lg-rez / Gestion des données

Déclaration de toutes les tables, colonnes, méthodes, et connection à la BDD

lgrez.bdd.tables¶

Dictionnaire {nom de la base -> table}, automatiquement rempli par sqlalchemy.ext.declarative.declarative_base() (via le paramètre class_registry).

Type: dict[str, base.TableBase subclass]

exception lgrez.bdd.SQLAlchemyError[source]¶: Alias de sqlalchemy.exc.SQLAlchemyError : exception de BDD générale.

exception lgrez.bdd.DriverOperationalError¶: Alias de sqlalchemy.exc.OperationalError : erreur levée en cas de perte de connexion avec la BDD. Seul PostreSQL est géré nativement : le cas échéant, remplacer cette exception par l’équivalent pour un autre driver.

lgrez.bdd.connect()[source]¶

Se connecte à la base de données et prépare les objets connectés.

Utilise la variable d’environment LGREZ_DATABASE_URI
Crée les tables si nécessaire
Prépare config.engine et config.session

`.base`¶

lg-rez / bdd / Briques de connection

Métaclasse et classe de base des tables de données, fonction de connection

class lgrez.bdd.base.TableMeta(name, bases, dic, comment=None, **kwargs)[source]¶

Métaclasse des tables de données de LG-Rez.

Sous-classe de sqlalchemy.orm.decl_api.DeclarativeMeta.

Cette métaclasse :

nomme automatiquement la table cls.__name__.lower() + "s",
ajoute une note commune aux docstrings de chaque classe,
définit des méthodes et propriétés de classe simplifiant l’utilisation des tables.

property attrs¶

Attributs de données publics des instances (dictionnaire nom -> colonne / relationship).

Type: Mapping[str, sqlalchemy.schema.Column | sqlalchemy.orm.RelationshipProperty]

property columns¶

Raccourci pour Table.__table__.columns (pseudo-dictionnaire nom -> colonne).

Comportement global de dictionnaire :

Table.columns["nom"] -> colonne associée ;

Table.columns.keys() -> noms des colonnes ;

Table.columns.values() -> objets Column ;

Table.columns.items() -> tuples (nom, colonne) ;

MAIS itération sur les colonnes (valeurs du dictionnaire) :

list(Table.columns) -> objets Column ;

for col in Table.columns -> objets Column.

Type: sqlalchemy.sql.base.ImmutableColumnCollection

find_nearest(chaine, col=None, sensi=0.25, filtre=None, solo_si_parfait=True, parfaits_only=True, match_first_word=False)[source]¶

Recherche les plus proches résultats d’une chaîne donnée.

Paramètres

chaine (str) – motif à rechercher
col (sqlalchemy.schema.Column | str) – colonne selon laquelle rechercher (défaut : colonne primaire). Doit être de type textuel.
sensi (float) – score* minimal pour retenir une entrée
filtre (BinaryExpression) – argument de query.filter() (ex. Table.colonne == valeur)
solo_si_parfait (bool) – si True (défaut), renvoie uniquement le premier élément de score* 1 trouvé s’il existe (ignore les autres éléments, même si >= sensi ou même 1)
parfaits_only (bool) – si True (défaut), ne renvoie que les éléments de score* 1 si on en trouve au moins un (ignore les autres éléments, même si >= sensi ; pas d’effet si solo_si_parfait vaut True)
match_first_word (bool) – si True, teste aussi chaine vis à vis du premier mot (caractères précédentla première espace) de chaque entrée, et conserve ce score si il est supérieur.

Renvoie

Les entrées correspondant le mieux à chaine, sous forme de liste de tuples (element, score*) triés par score* décroissant (et ce même si un seul résultat).

Type renvoyé

list[(TableBase, float)]

Lève

ValueError – col inexistante ou pas de type textuel
NotReadyError – session non initialisée (lgrez.config.session vaut None)

*score = ratio de difflib.SequenceMatcher, i.e. proportion de caractères communs aux deux chaînes.

Note

Les chaînes sont comparées sans tenir compte de l’accentuation ni de la casse.

property primary_col¶

Colonne clé primaire de la table.

Lève: ValueError – Pas de colonne clé primaire pour cette table, ou plusieurs
Type: sqlalchemy.schema.Column

property query¶

Raccourci pour .config.session.query(Table).

Lève: ready_check.NotReadyError – session non initialisée (config.session vaut None)
Type: sqlalchemy.orm.query.Query

lgrez.bdd.base.autodoc_Column(*args, doc='', comment=None, **kwargs)[source]¶

Returns Python-side and SQL-side well documented Column.

Use exactly as sqlalchemy.Column.

Paramètres

*args – passed to sqlalchemy.schema.Column.
**kwargs – passed to sqlalchemy.schema.Column.
doc (str) – column description, enhanced with column infos (Python and SQL types, if nullable, primary…) and passed to Column.doc.
comment (str) – passed to Column.comment; defaults to doc (not enhanced). Set it to '' to disable comment creation.

Renvoie

sqlalchemy.schema.Column

lgrez.bdd.base.autodoc_DynamicOneToMany(tablename, *args, doc='', **kwargs)[source]¶

Returns Python-side well documented dynamic one-to-many relationship.

Represents a relationship where each element in this table is linked to a lot of elements in tablename, itself back- refering to one element in this table.

The difference with autodoc_OneToMany() is that items are NOT accessible directly through class attribute, which returns a query that but must be fetched first:

Examples: Editor.books.all(), Editor.books.filter_by(...).one()

Use exactly as sqlalchemy.orm.dynamic_loader().

Paramètres

*args – passed to sqlalchemy.orm.dynamic_loader.
**kwargs – passed to sqlalchemy.orm.dynamic_loader.
doc (str) – relationship description, enhanced with class name and relationship type.

Renvoie

sqlalchemy.orm.RelationshipProperty

lgrez.bdd.base.autodoc_ManyToMany(tablename, *args, doc='', **kwargs)[source]¶

Returns Python-side well documented many-to-many relationship.

Represents a relationship where each element in this table is linked to several elements in tablename, itself back- refering to several elements in this table.

Example: Book.authors (each book has several authors, an author writes several books)

Use exactly as sqlalchemy.orm.relationship().

Paramètres

*args – passed to sqlalchemy.orm.relationship.
**kwargs – passed to sqlalchemy.orm.relationship.
doc (str) – relationship description, enhanced with class name and relationship type.

Renvoie

sqlalchemy.orm.RelationshipProperty

lgrez.bdd.base.autodoc_ManyToOne(tablename, *args, doc='', nullable=False, **kwargs)[source]¶

Returns Python-side well documented many-to-one relationship.

Represents a relationship where each element in this table is linked to one element in tablename, itself back-refering to several elements in this table.

Example: Book.editor (each book has an editor, an editor publishes several books)

Use exactly as sqlalchemy.orm.relationship(), plus the keyword argument nullable (see below).

Paramètres

*args – passed to sqlalchemy.orm.relationship.
**kwargs – passed to sqlalchemy.orm.relationship.
doc (str) – relationship description, enhanced with class name and relationship type.
nullable (bool) – indicates whether the relationship can be omitted (impacts docs only, default False).

Renvoie

sqlalchemy.orm.RelationshipProperty

lgrez.bdd.base.autodoc_OneToMany(tablename, *args, doc='', **kwargs)[source]¶

Returns Python-side well documented one-to-many relationship.

Represents a relationship where each element in this table is linked to several elements in tablename, itself back- refering to one element in this table.

Example: Editor.books (an editor publishes several books, each book has an editor)

Use exactly as sqlalchemy.orm.relationship().

Paramètres

*args – passed to sqlalchemy.orm.relationship.
**kwargs – passed to sqlalchemy.orm.relationship.
doc (str) – relationship description, enhanced with class name and relationship type.

Renvoie

sqlalchemy.orm.RelationshipProperty

Table de base¶

class lgrez.bdd.base.TableBase(**kwargs)¶

Classe de base des tables de données.

(construite par sqlalchemy.orm.registry.generate_base())

add(*other)[source]¶

Enregistre l’instance dans la base de donnée et commit.

Semble équivalent à update() si l’instance est déjà présente en base.

Paramètres: *other – autres instances à enregistrer dans le même commit, éventuellement. Utilisation recommandée : <Table>.add(*items).

Exemples

item.add()
<Table>.add(*items)

Globlament équivalent à:

config.session.add(self)
config.session.add_all(other)

config.session.commit()

static update()[source]¶

Applique les modifications en attente en base (commit).

Toutes les modifications, y compris des autres instances, seront enregistrées.

Globlament équivalent à:

config.session.commit()

delete(*other)[source]¶

Supprime l’instance de la base de données et commit.

Paramètres: *other – autres instances à supprimer dans le même commit, éventuellement.

Exemples

item.delete()
<Table>.delete(*items)

Lève: sqlalchemy.exc.SAWarning – l’instance a déjà été supprimmée (Warning, pas exception : ne bloque pas l’exécution).

Globlament équivalent à:

config.session.delete(self)
for item in others:
    config.session.delete(item)

config.session.commit()

Enums¶

lg-rez / bdd / Enums

Déclaration des énumérations utilisées

Énumérations (sous-classes de enum.Enum) utilisées dans les différentes tables du modèle de données :

class lgrez.bdd.Statut(value)[source]¶

Enum représentant le statut RP d’un Joueur.

vivant¶: Le joueur est en vie !

mort¶: Le joueur est mort. RIP.

MV¶: Le joueur est Mort-Vivant. Pas de chance.

immortel¶: Le joueur est Immortel. Si jamais…

class lgrez.bdd.ActionTrigger(value)[source]¶

Enum : Déclencheur de l’ouverture/fermeture d’une Action.

temporel¶: Ouverture/fermeture à heure fixe chaque jour

delta¶: Fermeture un délai donné après l’ouverture

perma¶: Action utilisable en permanence

start¶: Ouverture au lancement du jeu

auto¶: Action automatique, fermeture dès l’ouverture

mort¶: Ouverture à la mort

mot_mjs¶: Ouverture/fermeture au !plot cond

open_cond¶: À l’ouverture du vote condamné

close_cond¶: À la fermeture du vote condamné

open_maire¶: À l’ouverture du vote du maire

close_maire¶: À la fermeture du vote du maire

open_loups¶: À l’ouverture du vote des loups

close_loups¶: À la fermeture du vote des loups

class lgrez.bdd.CandidHaroType(value)[source]¶

Enum pour distinguer un haro d’une candidature.

candidature¶: Candidature à la mairie

haro¶: Haro pour le bûcher

class lgrez.bdd.Vote(value)[source]¶

Enum représentant les différents votes possibles.

cond¶: Vote pour le condamné du jour

maire¶: Vote pour le nouveau maire

loups¶: Vote pour la victime des loups

class lgrez.bdd.UtilEtat(value)[source]¶

Enum représentant l’état d’une utilisation d’action.

ouverte¶: Action utilisable, pas de décision prise

remplie¶: Décision prise, encore possibilité de changer

validee¶: Décision prise et bloquée (créneau pour agir fini)

ignoree¶: Créneau pour agir fini sans qu’une décision soit prise

contree¶: Utilisation validée, mais contrée par un évènement externe

class lgrez.bdd.CibleType(value)[source]¶

Enum représentant le type de cible d’une action.

joueur¶: La cible doit être un joueur, vivant ou mort

vivant¶: La cible doit être un joueur vivant

mort¶: La cible doit être un joueur mort

role¶: La cible doit être un rôle existant

camp¶: La cible doit être un camp (public) existant

booleen¶: Oui/non : sert à ue action sans paramètres, à une option…

texte¶: Permet d’entrer un texte libre

Modèle de données - Joueurs¶

lg-rez / bdd / Modèle de données

Déclaration de toutes les tables et leurs colonnes

Enregistrement des joueurs et de leurs actions publiques

Joueurs¶

class lgrez.bdd.Joueur(**kwargs)[source]¶

Table de données des joueurs inscrits.

Les instances de cette classe correspondent aux lignes du Tableau de bord ; elles sont crées par l’inscription (inscription.main()) et synchronisées par !sync.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table joueurs :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

discord_id¶

ID Discord du joueur (clé primaire) (NOT NULL)

Type SQLAlchemy : BigInteger() / Type SQL : BIGINT

Type: int

chan_id_¶

ID du chan privé Discord du joueur. (le ``_`` final indique que ce champ n’est pas synchnisé avec le Tableau de bord) (NOT NULL)

Type SQLAlchemy : BigInteger() / Type SQL : BIGINT

Type: int

nom¶

Nom du joueur (demandé à l’inscription) (NOT NULL)

Type SQLAlchemy : String(length=32) / Type SQL : VARCHAR(32)

Type: str

chambre¶

Emplacement du joueur (demandé à l’inscription)

Type SQLAlchemy : String(length=200) / Type SQL : VARCHAR(200)

Type: str | None

statut¶

Statut RP (NOT NULL) (défaut <Statut.vivant: 1>)

Type SQLAlchemy : Enum('vivant', 'mort', 'MV', 'immortel', name='statut') / Type SQL : VARCHAR(8)

Type: Statut

role¶

Rôle du joueur (défaut bdd.Role.default()) (many-to-one relationship) (NOT NULL)

Type: Role

camp¶

Camp du joueur (défaut bdd.Camp.default()) (many-to-one relationship) (NOT NULL)

Type: Camp

votant_village¶

Le joueur participe aux votes du village ? (NOT NULL) (défaut True)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

votant_loups¶

Le joueur participe au vote des loups ? (NOT NULL) (défaut False)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

role_actif¶

Le joueur peut agir ? (pas chatgarouté…) (NOT NULL) (défaut True)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

actions¶

Actions pour ce joueur (one-to-many relationship)

Type: Sequence[Action]

candidharos¶

Candidatures et haros de/contre ce joueur (one-to-many relationship)

Type: Sequence[CandidHaro]

bouderies¶

Appartenances aux boudoirs de ce joueur (one-to-many relationship)

Type: Sequence[Bouderie]

ciblages¶

Ciblages prenant ce joueur pour cible (dynamic one-to-many relationship)

Type: Query[Ciblage]

property member¶

Membre Discord correspondant à ce Joueur.

Lève

ValueError – pas de membre correspondant
NotReadyError – bot non connecté (config.guild vaut None)

Type

discord.Member

property private_chan¶

Channel privé (conversation bot) du joueur.

Lève

ValueError – pas de channel correspondant
NotReadyError – bot non connecté (config.guild vaut None)

Type

discord.TextChannel

property actions_actives¶

Sous-ensemble de actions restreint aux actions actives.

Élimine aussi les actions de vote (sans base).

Type: Sequence[.bdd.Action]

property boudoirs¶

Boudoirs où est ce jour (read-only)

Type: Sequence[.Boudoir]

est_vivant¶

bool (instance) / sqlalchemy.sql.selectable.Exists (classe): Le joueur est en vie ou MVtisé ?

Raccourci pour joueur.statut in {Statut.vivant, Statut.MV}

Propriété hybride (voir Action.is_open pour plus d’infos)

est_mort¶

bool (instance) / sqlalchemy.sql.selectable.Exists (classe): Le joueur est mort ?

Raccourci pour joueur.statut == Statut.mort

Propriété hybride (voir Action.is_open pour plus d’infos)

classmethod from_member(member)[source]¶

Récupère le Joueur (instance de BDD) lié à un membre Discord.

Paramètres

member (discord.Member) – le membre concerné

Renvoie

Le joueur correspondant.

Type renvoyé

Joueur

Lève

ValueError – membre introuvable en base
NotReadyError – session non initialisée (config.session vaut None)

action_vote(vote)[source]¶

Retourne l“« action de vote » voulue pour ce joueur.

Paramètres: vote (.bdd.Vote) – vote pour lequel récupérer l’action
Renvoie: Action
Lève: RuntimeError – action non existante

CandidHaros¶

class lgrez.bdd.CandidHaro(**kwargs)[source]¶

Table de données des candidatures et haros en cours #PhilippeCandidHaro.

Les instances sont enregistrées via !haro / !candid et supprimées via !wipe.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table candidharos :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

id¶

Identifiant unique du candidharo, sans signification (clé primaire) (auto-incrémental)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

joueur¶

Joueur concerné (candidat ou haroté) (many-to-one relationship) (NOT NULL)

Type: Joueur

type¶

Haro ou candidature ? (NOT NULL)

Type SQLAlchemy : Enum('candidature', 'haro', name='candidharotype') / Type SQL : VARCHAR(11)

Type: CandidHaroType

Boudoirs¶

class lgrez.bdd.Boudoir(**kwargs)[source]¶

Table de données des boudoirs sur le serveur.

Les instances de cette classe sont crées, modifiées et supprimées par !boudoir.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table boudoirs :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

chan_id¶

ID Discord du salon (clé primaire) (NOT NULL)

Type SQLAlchemy : BigInteger() / Type SQL : BIGINT

Type: int

nom¶

Nom du boudoir (demandé à la création) (NOT NULL)

Type SQLAlchemy : String(length=80) / Type SQL : VARCHAR(80)

Type: str

ts_created¶

Timestamp de la création (NOT NULL)

Type SQLAlchemy : DateTime() / Type SQL : DATETIME

Type: datetime.datetime

bouderies¶

Appartenances à ce boudoir (one-to-many relationship)

Type: Sequence[Bouderie]

property chan¶

Salon Discord correspondant à ce boudoir.

Lève

ValueError – pas de membre correspondant
NotReadyError – bot non connecté (config.guild vaut None)

Type

discord.TextChannel

property joueurs¶

Joueurs présents dans ce boudoir (read-only)

Type: Sequence[.Joueur]

property gerant¶

Membre du boudoir ayant les droits de gestion (r+w).

Lève: ValueError – pas de membre avec les droits de gestion
Type: .bdd.Joueur

classmethod from_channel(channel)[source]¶

Récupère le Boudoir (instance de BDD) lié à un salon Discord.

Paramètres

channel (discord.TextChannel) – le salon concerné

Renvoie

Le salon correspondant.

Type renvoyé

.Boudoir

Lève

ValueError – boudoir introuvable en base
NotReadyError – session non initialisée (config.session vaut None)

Bouderies¶

class lgrez.bdd.Bouderie(**kwargs)[source]¶

Table de données des appartenances aux boudoirs du serveur.

Table d’association entre Joueur et Boudoir.

Les instances de cette classe sont crées, modifiées et supprimées par !boudoir.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table bouderies :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

id¶

Identifiant unique de la bouderie, sans signification (clé primaire) (auto-incrémental)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

joueur¶

Joueur concerné (many-to-one relationship) (NOT NULL)

Type: Joueur

boudoir¶

Boudoir concerné (many-to-one relationship) (NOT NULL)

Type: Boudoir

gerant¶

Si le joueur a les droits de gestion du boudoir (NOT NULL) (défaut False)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

ts_added¶

Timestamp de l’ajout du joueur au boudoir (NOT NULL)

Type SQLAlchemy : DateTime() / Type SQL : DATETIME

Type: datetime.datetime

ts_promu¶

Timestamp de la promotion en gérant, le cas échéant

Type SQLAlchemy : DateTime() / Type SQL : DATETIME

Type: datetime.datetime | None

Modèle de données - Jeu¶

lg-rez / bdd / Modèle de données

Déclaration de toutes les tables et leurs colonnes

Personnalisation des rôles, camps et actions liées

Rôles¶

class lgrez.bdd.Role(**kwargs)[source]¶

Table de données des rôles.

Cette table est remplie automatiquement à partir du Google Sheet « Rôles et actions » par la commande !fillroles.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table roles :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

slug¶

Identifiant unique du rôle (clé primaire) (NOT NULL)

Type SQLAlchemy : String(length=32) / Type SQL : VARCHAR(32)

Type: str

prefixe¶

Article du nom du rôle ("Le ", "La ", "L'"…) (NOT NULL) (défaut '')

Type SQLAlchemy : String(length=8) / Type SQL : VARCHAR(8)

Type: str

nom¶

Nom (avec casse et accents) du rôle (NOT NULL)

Type SQLAlchemy : String(length=32) / Type SQL : VARCHAR(32)

Type: str

camp¶

Camp auquel ce rôle est affilié à l’origine (many-to-one relationship) (NOT NULL)

(On peut avoir joueur.camp != joueur.role.camp si damnation, passage MV…)

Type: Camp

actif¶

Rôle actif ? (affiché dans la liste des rôles, etc) (NOT NULL) (défaut True)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

description_courte¶

Description du rôle en une ligne (NOT NULL) (défaut '')

Type SQLAlchemy : String(length=140) / Type SQL : VARCHAR(140)

Type: str

description_longue¶

Règles et background complets du rôle (NOT NULL) (défaut '')

Type SQLAlchemy : String(length=1800) / Type SQL : VARCHAR(1800)

Type: str

joueurs¶

Joueurs ayant ce rôle (one-to-many relationship)

Type: Sequence[Joueur]

ciblages¶

Ciblages prenant ce rôle pour cible (dynamic one-to-many relationship)

Type: Query[Ciblage]

base_actions¶

Modèles d’actions associées (many-to-many relationship)

Type: Sequence[BaseAction]

property nom_complet¶

Préfixe + nom du rôle

Type: str

property embed¶

Embed Discord présentant le rôle et ses actions.

Type: discord.Embed

classmethod default()[source]¶

Retourne le rôle par défaut (celui avant attribution).

Avertissement

Un rôle de slug config.default_role_slug doit être défini en base.

Renvoie

~bdd.Role

Lève

ValueError – rôle introuvable en base
RuntimeError – session non initialisée (config.session vaut None)

Camps¶

class lgrez.bdd.Camp(**kwargs)[source]¶

Table de données des camps, publics et secrets.

Cette table est remplie automatiquement à partir du Google Sheet « Rôles et actions » par la commande !fillroles.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table camps :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

slug¶

Identifiant unique du camp (clé primaire) (NOT NULL)

Type SQLAlchemy : String(length=32) / Type SQL : VARCHAR(32)

Type: str

nom¶

Nom (affiché) du camp (NOT NULL)

Type SQLAlchemy : String(length=32) / Type SQL : VARCHAR(32)

Type: str

description¶

Description (courte) du camp (NOT NULL) (défaut '')

Type SQLAlchemy : String(length=1000) / Type SQL : VARCHAR(1000)

Type: str

public¶

L’existance du camp (et des rôles liés) est connue de tous ? (NOT NULL) (défaut True)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

emoji¶

Nom de l’emoji associé au camp (doit être le nom d’un emoji existant sur le serveur)

Type SQLAlchemy : String(length=32) / Type SQL : VARCHAR(32)

Type: str | None

joueurs¶

Joueurs appartenant à ce camp (one-to-many relationship)

Type: Sequence[Joueur]

roles¶

Rôles affiliés à ce camp de base (one-to-many relationship)

Type: Sequence[Role]

ciblages¶

Ciblages prenant ce camp pour cible (dynamic one-to-many relationship)

Type: Query[Ciblage]

property discord_emoji¶

Emoji Discord correspondant à ce camp

Lève

ValueError – emoji non défini ou manquant sur le serveur
NotReadyError – bot non connecté (config.guild vaut None)

Type

discord.Emoji

property discord_emoji_or_none¶

discord_emoji si défini

Lève: NotReadyError – bot non connecté (config.guild vaut None)
Type: discord.Emoji | None

property embed¶

Embed Discord présentant le camp.

Type: discord.Embed

classmethod default()[source]¶

Retourne le camp par défaut (celui avant attribution).

Avertissement

Un camp de slug config.default_camp_slug doit être défini en base.

Renvoie

~bdd.Camp

Lève

ValueError – camp introuvable en base
RuntimeError – session non initialisée (config.session vaut None)

Actions de base¶

class lgrez.bdd.BaseAction(**kwargs)[source]¶

Table de données des actions définies de base (non liées à un joueur).

Cette table est remplie automatiquement à partir du Google Sheet « Rôles et actions » par la commande !fillroles.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table baseactions :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

slug¶

Identifiant unique de l’action (clé primaire) (NOT NULL)

Type SQLAlchemy : String(length=32) / Type SQL : VARCHAR(32)

Type: str

trigger_debut¶

Mode de déclenchement de l’ouverture de l’action (NOT NULL) (défaut <ActionTrigger.perma: 3>)

Type SQLAlchemy : Enum('temporel', 'delta', 'perma', 'start', 'auto', 'mort', 'mot_mjs', 'open_cond', 'close_cond', 'open_maire', 'close_maire', 'open_loups', 'close_loups', name='actiontrigger') / Type SQL : VARCHAR(11)

Type: ActionTrigger

trigger_fin¶

Mode de déclenchement de la clôture de l’action (NOT NULL) (défaut <ActionTrigger.perma: 3>)

Type SQLAlchemy : Enum('temporel', 'delta', 'perma', 'start', 'auto', 'mort', 'mot_mjs', 'open_cond', 'close_cond', 'open_maire', 'close_maire', 'open_loups', 'close_loups', name='actiontrigger') / Type SQL : VARCHAR(11)

Type: ActionTrigger

instant¶

L’action est instantannée (conséquence dès la prise de décision) ou non (conséquence à la fin du créneau d’action) (NOT NULL) (défaut False)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

heure_debut¶

Si trigger_debut vaut temporel, l’horaire associé

Type SQLAlchemy : Time() / Type SQL : TIME

Type: datetime.time | None

heure_fin¶

Si trigger_fin vaut - temporel : l’horaire associé ; - delta, l’intervalle associé

Type SQLAlchemy : Time() / Type SQL : TIME

Type: datetime.time | None

base_cooldown¶

Temps de rechargement entre deux utilisations du pouvoir (0 si pas de cooldown) (NOT NULL) (défaut 0)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

base_charges¶

Nombre de charges initiales du pouvoir (None si illimité)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int | None

refill¶

Évènements pouvant recharger l’action, séparés par des virgules ("weekends", "forgeron", "rebouteux"…) (NOT NULL) (défaut '')

Type SQLAlchemy : String(length=32) / Type SQL : VARCHAR(32)

Type: str

lieu¶

Attribut informatif, non exploité dans la version actuelle (Distance/Physique/Lieu/Contact/Conditionnel/None/Public)

Type SQLAlchemy : String(length=100) / Type SQL : VARCHAR(100)

Type: str | None

interaction_notaire¶

Attribut informatif, non exploité dans la version actuelle (Oui/Non/Conditionnel/Potion/Rapport ; None si récursif)

Type SQLAlchemy : String(length=100) / Type SQL : VARCHAR(100)

Type: str | None

interaction_gardien¶

Attribut informatif, non exploité dans la version actuelle (Oui/Non/Conditionnel/Taverne/Feu/MaisonClose/Précis/Cimetière/Loups ; None si récursif)

Type SQLAlchemy : String(length=100) / Type SQL : VARCHAR(100)

Type: str | None

mage¶

Attribut informatif, non exploité dans la version actuelle (Oui/Non/Changement de cible/…)

Type SQLAlchemy : String(length=100) / Type SQL : VARCHAR(100)

Type: str | None

decision_format¶

Tuer {cible}) (NOT NULL) (défaut '')

Type SQLAlchemy : String(length=200) / Type SQL : VARCHAR(200)

Type: str
Type: Description des utilisations de ces action, sous forme de texte formaté avec les noms des BaseCiblage.slug entre accolades (exemple

actions¶

Actions déroulant de cette base (one-to-many relationship)

Type: Sequence[Action]

base_ciblages¶

Ciblages de ce modèle d’action (triés par priorité) (one-to-many relationship)

Type: Sequence[BaseCiblage]

roles¶

Rôles ayant cette action de base (many-to-many relationship)

Type: Sequence[Role]

property temporalite¶

Phrase décrivant le mode d’utilisation / timing de l’action.

Type: str

Ciblages de base¶

class lgrez.bdd.BaseCiblage(**kwargs)[source]¶

Table de données des modèles de ciblages des actions de base.

[TODO] Cette table est remplie automatiquement à partir du Google Sheet « Rôles et actions » par la commande !fillroles.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table baseciblages :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

base_action¶

Modèle d’action définissant ce ciblage (many-to-one relationship) (NOT NULL)

Type: BaseAction

slug¶

Identifiant de la cible dans le modèle d’action (NOT NULL) (défaut 'unique')

Type SQLAlchemy : String(length=32) / Type SQL : VARCHAR(32)

Type: str

type¶

Message d’interaction au joueur au moment de choisir la cible (NOT NULL) (défaut <CibleType.texte: 7>)

Type SQLAlchemy : Enum('joueur', 'vivant', 'mort', 'role', 'camp', 'booleen', 'texte', name='cibletype') / Type SQL : VARCHAR(7)

Type: CibleType

prio¶

Ordre (relatif) d’apparition du ciblage lors du !action

Si deux ciblages ont la même priorité, ils seront considérés comme ayant une signification symmétrique (notamment, si doit_changer vaut True, tous les membres du groupe devront changer) ; l’ordre d’apparition dépend alors de leur slug, par ordre alphabétique (cible1 < cible2). (NOT NULL) (défaut 1)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

phrase¶

Message d’interaction au joueur au moment de choisir la cible (NOT NULL) (défaut 'Cible ?')

Type SQLAlchemy : String(length=1000) / Type SQL : VARCHAR(1000)

Type: str

obligatoire¶

Si le ciblage doit obligatoirement être renseigné (NOT NULL) (défaut True)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

doit_changer¶

Si la cible doit changer d’une utilisation à l’autre.

Si la dernière utilisation est ignorée ou contrée, il n’y a pas de contrainte. (NOT NULL) (défaut False)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

ciblages¶

Ciblages déroulant de cette base (dynamic one-to-many relationship)

Type: Query[Ciblage]

Modèle de données - Actions¶

lg-rez / bdd / Modèle de données

Déclaration de toutes les tables et leurs colonnes

Actions, leurs utilisations et ciblages (à venir)

Actions¶

class lgrez.bdd.Action(*args, **kwargs)[source]¶

Table de données des actions attribuées (liées à un joueur).

Les instances doivent être enregistrées via gestion_actions.add_action() et supprimées via gestion_actions.delete_action().

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table actions :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

id¶

Identifiant unique de l’action, sans signification (clé primaire) (auto-incrémental)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

joueur¶

Joueur concerné (many-to-one relationship) (NOT NULL)

Type: Joueur

base¶

Action de base (None si action de vote) (many-to-one relationship)

Type: BaseAction | None

vote¶

Si action de vote, vote concerné

Type SQLAlchemy : Enum('cond', 'maire', 'loups', name='vote') / Type SQL : VARCHAR(5)

Type: Vote | None

active¶

Si l’action est actuellement utilisable (False = archives) (NOT NULL) (défaut True)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool

cooldown¶

Nombre d’ouvertures avant disponiblité de l’action (NOT NULL) (défaut 0)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

charges¶

Nombre de charges restantes (None si illimité)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int | None

taches¶

Tâches liées à cette action (one-to-many relationship)

Type: Sequence[Tache]

utilisations¶

Utilisations de cette action (dynamic one-to-many relationship)

Type: Query[Utilisation]

property utilisation_ouverte¶

Utilisation de l’action actuellement ouverte.

Vaut None si aucune action n’a actuellement l’état ouverte ou remplie.

Lève

RuntimeError – plus d’une action a actuellement l’état
ouverte –

Type

Utilisation | None

property derniere_utilisation¶

Utilisation | None:: Dernière utilisation de cette action (temporellement).

Considère l’utilisation ouverte le cas échéant, sinon la dernière utilisation par timestamp de fermeture descendant (quelque soit son état, y comprs contree).

Vaut None si l’action n’a jamais été utilisée.

Lève

RuntimeError – plus d’une action a actuellement l’état
ouverte –

property decision¶

Description de la décision de la dernière utilisation.

Considère l’utilisation ouverte le cas échéant, sinon la dernière utilisation par timestamp de fermeture descendant.

Vaut Utilisation.decision, ou "<N/A>" si il n’y a aucune utilisation de cette action.

Lève

RuntimeError – plus d’une action a actuellement l’état
ouverte –

Type

str

is_open¶

bool (instance) / sqlalchemy.sql.selectable.Exists (classe): L’action est ouverte (l’utilisateur peut interagir) ?

I.e. l’action a au moins une utilisation ouverte ou remplie.

Propriété hybride (sqlalchemy.ext.hybrid.hybrid_property) :

Sur l’instance, renvoie directement la valeur booléenne ;

Sur la classe, renvoie la clause permettant de déterminer si l’action est en attente.

Examples:

action.is_open          # bool
Joueur.query.filter(Joueur.actions.any(Action.is_open)).all()

is_waiting¶

bool (instance) / sqlalchemy.sql.selectable.Exists (classe): L’action est ouverte et aucune décision n’a été prise ?

I.e. la clause a au moins une utilisation ouverte.

Propriété hybride (voir is_open pour plus d’infos)

Utilisations¶

class lgrez.bdd.Utilisation(**kwargs)[source]¶

Table de données des utilisations des actions.

Les instances sont enregistrées via !open ; elles n’ont pas vocation à être supprimées.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table utilisations :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

id¶

Identifiant unique de l’utilisation, sans signification (clé primaire) (auto-incrémental)

Type SQLAlchemy : BigInteger() / Type SQL : BIGINT

Type: int

action¶

Action utilisée (many-to-one relationship) (NOT NULL)

Type: Action

etat¶

État de l’utilisation (NOT NULL) (défaut <UtilEtat.ouverte: 1>)

Type SQLAlchemy : Enum('ouverte', 'remplie', 'validee', 'ignoree', 'contree', name='utiletat') / Type SQL : VARCHAR(7)

Type: UtilEtat

ts_open¶

Timestamp d’ouverture de l’utilisation

Type SQLAlchemy : DateTime() / Type SQL : DATETIME

Type: datetime.datetime | None

ts_close¶

Timestamp de fermeture de l’utilisation

Type SQLAlchemy : DateTime() / Type SQL : DATETIME

Type: datetime.datetime | None

ts_decision¶

Timestamp du dernier remplissage de l’utilisation

Type SQLAlchemy : DateTime() / Type SQL : DATETIME

Type: datetime.datetime | None

ciblages¶

Cibles désignées dans cette utilisation (one-to-many relationship)

Type: Sequence[Ciblage]

open()[source]¶

Ouvre cette utilisation.

Modifie son etat, définit ts_open au temps actuel, et update.

close()[source]¶

Clôture cette utilisation.

Modifie son etat, définit ts_close au temps actuel, et update.

ciblage(slug)[source]¶

Renvoie le ciblage de base de slug voulu.

Paramètres: slug (str) – Doit correspondre à un des slugs des bases des ciblages de l’utilisation.
Renvoie: bdd.Ciblage
Lève: ValueError – slug non trouvé dans les ciblages

property cible¶

Joueur ciblé par l’utilisation, si applicable.

Cet attribut n’est accessible que si l’utilisation est d’un vote ou d’une action définissant un et une seul ciblage de type joueur, vivant ou mort.

Vaut None si l’utilisation a l’état ouverte ou ignoree.

Lève

ValueError – l’action ne remplit pas les critères évoqués
ci-dessus –

Type

Joueur | None

property decision¶

Description de la décision de cette utilisation.

Complète le template de :.bdd.BaseAction.decision_format` avec les valeurs des ciblages de l’utilisation.

Vaut "Ne rien faire" si l’utilisation n’a pas de ciblages, et cible dans le cas d’un vote.

Type: str

is_open¶

bool (instance) / sqlalchemy.sql.selectable.Exists (classe): L’utilisation est ouverte (l’utilisateur peut interagir) ?

Raccourci pour utilisation.etat in {UtilEtat.ouverte, UtilEtat.remplie}

Propriété hybride (voir Action.is_open pour plus d’infos)

is_waiting¶

bool (instance) / sqlalchemy.sql.selectable.Exists (classe): L’utilisation est ouverte et aucune décision n’a été prise ?

Raccourci pour utilisation.etat == UtilEtat.ouverte

Propriété hybride (voir Action.is_open pour plus d’infos)

is_filled¶

bool (instance) / sqlalchemy.sql.selectable.Exists (classe): L’utilisation est remplie (l’utilisateur a interagi avec) ?

Raccourci pour utilisation.etat in {UtilEtat.remplie, UtilEtat.validee, UtilEtat.contree}

Propriété hybride (voir Action.is_open pour plus d’infos)

Ciblages¶

class lgrez.bdd.Ciblage(**kwargs)[source]¶

Table de données des cibles désignées dans les utilisations d’actions.

Les instances sont enregistrées via !action ; elles n’ont pas vocation à être supprimées.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table ciblages :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

id¶

Identifiant unique du ciblage, sans signification (clé primaire) (auto-incrémental)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

base¶

Modèle de ciblage (lié au modèle d’action). Vaut None pour un ciblage de vote (many-to-one relationship)

Type: BaseCiblage | None

utilisation¶

Utilisation où ce ciblage a été fait (many-to-one relationship) (NOT NULL)

Type: Utilisation

joueur¶

Joueur désigné, si base.type vaut joueur, vivant ou mort (many-to-one relationship)

Type: Joueur | None

role¶

Rôle désigné, si base.type vaut role (many-to-one relationship)

Type: Role | None

camp¶

Camp désigné, si base.type vaut camp (many-to-one relationship)

Type: Camp | None

booleen¶

Valeur, si base.type vaut booleen

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool | None

texte¶

Valeur, si base.type vaut texte

Type SQLAlchemy : String(length=1000) / Type SQL : VARCHAR(1000)

Type: str | None

property valeur¶

Joueur | Camp | bool | str: Valeur du ciblage, selon son type.

Propriété en lecture et écriture.

Lève: ValueError – ciblage de type inconnu

property valeur_descr¶

Description de la valeur du ciblage.

Si valeur vaut None, renvoie <N/A>

Lève: ValueError – ciblage de type inconnu
Type: str

Tâches¶

class lgrez.bdd.Tache(**kwargs)[source]¶

Table de données des tâches planifiées du bot.

Les instances doivent être enregistrées via add() et supprimées via delete().

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table taches :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

id¶

Identifiant unique de la tâche, sans signification (clé primaire) (auto-incrémental)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

timestamp¶

Moment où exécuter la tâche (NOT NULL)

Type SQLAlchemy : DateTime() / Type SQL : DATETIME

Type: datetime.datetime

commande¶

Texte à envoyer via le webhook (généralement une commande) (NOT NULL)

Type SQLAlchemy : String(length=2000) / Type SQL : VARCHAR(2000)

Type: str

action¶

Si la tâche est liée à une action, action concernée (many-to-one relationship)

Type: Action | None

property handler¶

Représentation dans le bot de la tâche.

Proxy pour config.bot.tasks[self.id], en lecture, écriture et suppression (del).

Lève: RuntimeError – tâche non enregistrée dans le bot.
Type: asyncio.TimerHandle

async send_webhook(tries=0)[source]¶

Exécute la tâche (coroutine programmée par execute()).

Envoie un webhook (config.webhook) de contenu commande.

Si une exception quelconque est levée par l’envoi du webhook, re-programme l’exécution de la tâche (execute()) 2 secondes après ; ce jusqu’à 5 fois, après quoi un message d’alerte est envoyé dans config.Channel.logs.

Si aucune exception n’est levée (succès), supprime la tâche.

Paramètres: tries (int) – Numéro de l’essai d’envoi actuellement en cours

execute(tries=0)[source]¶

Exécute la tâche planifiée (méthode appellée par la loop).

Programme send_webhook() pour exécution immédiate.

Paramètres: tries (int) – Numéro de l’essai d’envoi actuellement en cours, passé à send_webhook().

register()[source]¶: Programme l’exécution de la tâche dans la loop du bot.

cancel()[source]¶

Annule et nettoie la tâche planifiée (sans la supprimer en base).

Si la tâche a déjà été exécutée, ne fait que nettoyer le handler.

add(*other)[source]¶

Enregistre la tâche sur le bot et en base.

Globalement équivalent à un appel à register() (pour chaque élément le cas échéant) avant l’ajout en base habituel (TableBase.add).

Paramètres: *other – autres instances à ajouter dans le même commit, éventuellement.

delete(*other)[source]¶

Annule la tâche planifiée et la supprime en base.

Globalement équivalent à un appel à cancel() (pour chaque élément le cas échéant) avant la suppression en base habituelle (TableBase.add).

Paramètres: *other – autres instances à supprimer dans le même commit, éventuellement.

Modèle de données - IA¶

lg-rez / bdd / Modèle de données

Déclaration de toutes les tables et leurs colonnes

Réactions¶

class lgrez.bdd.Reaction(**kwargs)[source]¶

Table de données des réactions d’IA connues du bot.

Les instances sont enregistrées via !addIA et supprimées via !modifIA.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table reactions :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

id¶

Identifiant unique de la réaction, sans signification (clé primaire) (auto-incrémental)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

reponse¶

Réponse, suivant le format (mini-langage) personnalisé ("txt <||> txt <&&> <##>react") (NOT NULL)

Type SQLAlchemy : String(length=2000) / Type SQL : VARCHAR(2000)

Type: str

triggers¶

Déclencheurs associés (one-to-many relationship)

Type: Sequence[Trigger]

Triggers¶

class lgrez.bdd.Trigger(**kwargs)[source]¶

Table de données des mots et expressions déclenchant l’IA du bot.

Les instances sont enregistrées via !addIA ou !modifIA et supprimées via !modifIA.

Note

Cette classe est une classe de données (sous-classe de TableBase) représentant la table triggers :

Les propriétés et méthodes détaillées dans TableMeta sont utilisables (sur la classe uniquement) ;
Tous les attributs ci-dessous sont du type indiqué pour les instances (entrées de BDD), mais de type sqlalchemy.orm.attributes.InstrumentedAttribute pour la classe elle-même.

id¶

Identifiant unique du déclencheur, sans signification (clé primaire) (auto-incrémental)

Type SQLAlchemy : Integer() / Type SQL : INTEGER

Type: int

trigger¶

Mots-clés / expressions (NOT NULL)

Type SQLAlchemy : String(length=500) / Type SQL : VARCHAR(500)

Type: str

reaction¶

Réaction associée (many-to-one relationship) (NOT NULL)

Type: Reaction

`lgrez.bdd` (Gestion des données)¶

`.base`¶

Table de base¶

Enums¶

Modèle de données - Joueurs¶

Joueurs¶

CandidHaros¶

Boudoirs¶

Bouderies¶

Modèle de données - Jeu¶

Rôles¶

Camps¶

Actions de base¶

Ciblages de base¶

Modèle de données - Actions¶

Actions¶

Utilisations¶

Ciblages¶

Tâches¶

Modèle de données - IA¶

Réactions¶

Triggers¶

Table des matières

Sujet précédent

Sujet suivant

Cette page

lgrez.bdd (Gestion des données)¶

.base¶

Table de base¶

Enums¶

Modèle de données - Joueurs¶

Joueurs¶

CandidHaros¶

Boudoirs¶

Bouderies¶

Modèle de données - Jeu¶

Rôles¶

Camps¶

Actions de base¶

Ciblages de base¶

Modèle de données - Actions¶

Actions¶

Utilisations¶

Ciblages¶

Tâches¶

Modèle de données - IA¶

Réactions¶

Triggers¶

`lgrez.bdd` (Gestion des données)¶

`.base`¶