`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, TableBase subclass]

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

exception lgrez.bdd.DriverOperationalError¶: Alias de psycopg2.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.declarative.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¶: Mapping[str, sqlalchemy.schema.Column | sqlalchemy.orm.RelationshipProperty]: Attributs de données publics des instances (dictionnaire nom -> colonne / relationship).

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_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='', **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().

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_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.ext.declarative.declarative_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

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: lgrez.bdd.enums.Statut

role¶

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

Type: Role

camp¶

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

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

vote_condamne_¶

Vote actuel au vote condamné ( si pas de vote en cours). (le ``_`` final indique que ce champ n’est pas synchnisé avec le Tableau de bord)

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

Type: str | None

vote_maire_¶

Vote actuel au vote condamné (None si pas de vote en cours). (le ``_`` final indique que ce champ n’est pas synchnisé avec le Tableau de bord)

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

Type: str | None

vote_loups_¶

Vote actuel au vote loups (None si pas de vote en cours). (le ``_`` final indique que ce champ n’est pas synchnisé avec le Tableau de bord)

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

Type: str | None

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]

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

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)

CandidHaros¶

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

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

Les instances doivent être 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)

Type: Joueur

type¶

Haro ou candidature ? (NOT NULL)

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

Type: lgrez.bdd.enums.CandidHaroType

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)

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

Type: Camp

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=2000) / Type SQL : VARCHAR(2000)

Type: str

joueurs¶

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

Type: Sequence[Joueur]

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

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=140) / Type SQL : VARCHAR(140)

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]

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

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: lgrez.bdd.enums.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: lgrez.bdd.enums.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

changement_cible¶

Attribut informatif, non exploité dans la version actuelle (si la cible doit changer entre deux utilisations consécutives)

Type SQLAlchemy : Boolean() / Type SQL : BOOLEAN

Type: bool | None

actions¶

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

Type: Sequence[Action]

roles¶

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

Type: Sequence[Role]

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(**kwargs)[source]¶

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

Les instances doivent être enregistrées via gestion_actions.open_action() et supprimées via gestion_actions.close_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)

Type: Joueur

base¶

Action de base (many-to-one relationship)

Type: BaseAction

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

decision_¶

Décision prise par le joueur pour l’action actuelle (None si action pas en cours). (le ``_`` final n’indique rien de très pertinent, vivement que ça dégage)

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

Type: str | None

taches¶

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

Type: Sequence[Tache]

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

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

execute()[source]¶

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

Envoie un webhook (variable d’environnement LGREZ_WEBHOOK_URL) avec comme message commande, puis

si l’envoi est un succès, supprime la tâche (et son handler);

sinon, se ré-appelle dans 2 secondes.

Limitation interne de 2 secondes minimum entre deux appels (ré-appelle si appelée trop tôt), pour se conformer à la rate limit Discord (30 messages / minute) et ne pas engoncer la loop.

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 doivent être 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 doivent être 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 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)

Type: Reaction

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

`.base`¶

Table de base¶

Enums¶

Modèle de données - Joueurs¶

Joueurs¶

CandidHaros¶

Modèle de données - Jeu¶

Rôles¶

Camps¶

Actions de base¶

Modèle de données - Actions¶

Actions¶

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¶

Modèle de données - Jeu¶

Rôles¶

Camps¶

Actions de base¶

Modèle de données - Actions¶

Actions¶

Tâches¶

Modèle de données - IA¶

Réactions¶

Triggers¶

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

`.base`¶