nsarchive 1.3.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

nsarchive/cls/archives.py

@@ -2,69 +2,92 @@ import time
 
 from .base import *
 
-class Action:
-    def __init__(self, author: str | NSID = '0', target: str | NSID = '0') -> None:
+class Archive:
+    def __init__(self, author: NSID = '0', target: NSID = '0'):
+        """
+        Classe de référence pour toutes les archives.
+
+        ## Attributs de base
+        - date: `int`\n
+            Date (timestamp) de l'exécution de l'archive
+        - id: `NSID`\n
+            Clé d'identification des archives (basée sur la date)
+        - author: `NSID`\n
+            ID de l'auteur de l'action
+        - target: `NSID`:
+            ID de la cible de l'action
+        - action: `str`:\n
+            Action effectuée
+        - details: `dict`\n
+            Ensemble de détails que les différents bots peuvent utiliser
+        """
         self.date: int = round(time.time())
 
         self.id: NSID = NSID(self.date)
-        self.action: str = ""
         self.author: NSID = NSID(author)
         self.target: NSID = NSID(target)
 
+        self.action: str = ""
+        self.details: dict = {
+            "reason": None
+        }
 
-# Entities
 
-class Sanction(Action):
-    def __init__(self, author: str | NSID, target: str | NSID) -> None:
-        super().__init__(author, target)
-
-        self.details: str = ""
-        self.major: bool = False # Sanction majeure ou non
-        self.duration: int = 0 # Durée en secondes, 0 = définitif
+# Entities
 
-class AdminAction(Action):
-    def __init__(self, author: str | NSID, target: str | NSID) -> None:
+class Sanction(Archive):
+    def __init__(self, author: NSID, target: NSID) -> None:
         super().__init__(author, target)
 
-        self.details: str = ""
-        self.new_state: str | int | bool = None
+        self.details: dict = {
+            "reason": None,
+            "major": False, # Sanction majeure ou non
+            "duration": 0 # Durée en secondes , 0 = définitif
+        }
 
-class Report(Action):
-    def __init__(self, author: str | NSID, target: str | NSID) -> None:
+class Report(Archive):
+    def __init__(self, author: NSID, target: NSID) -> None:
         super().__init__(author, target)
 
-        self.details: str = ""
+        self.details: dict = {
+            "reason": None,
+            "elements": [] # Liste des pièces jointes
+        }
 
 
 # Community
 
-class Election(Action):
-    def __init__(self, author: str | NSID, target: str | NSID, position: str) -> None:
+class Election(Archive):
+    def __init__(self, author: NSID, target: NSID, position: str) -> None:
         super().__init__(author, target)
 
-        self.position: str = position
-        self.positive_votes: int = 0
-        self.total_votes: int = 0
+        self.details = {
+            "position": position,
+            "positive_votes": 0,
+            "total_votes": 0
+        }
 
-class Promotion(Action):
-    def __init__(self, author: str | NSID, target: str | NSID, position: str) -> None:
+class Promotion(Archive):
+    def __init__(self, author: NSID, target: NSID, position: str) -> None:
         super().__init__(author, target)
 
-        self.position: str = position
+        self.details = {
+            "position": position
+        }
 
-class Demotion(Action):
-    def __init__(self, author: str | NSID, target: str | NSID) -> None:
+class Demotion(Archive):
+    def __init__(self, author: NSID, target: NSID) -> None:
         super().__init__(author, target)
 
-        self.reason: str = None
-
 
 # Bank
 
-class Transaction(Action):
-    def __init__(self, author: str | NSID, target: str | NSID, amount: int) -> None:
+class Transaction(Archive):
+    def __init__(self, author: NSID, target: NSID) -> None:
         super().__init__(author, target)
 
-        self.amount: int = amount
-        self.currency: str = 'HC'
-        self.reason: str = None
+        self.details = {
+            "amount": 0,
+            "currency": "HC",
+            "reason": None
+        }

nsarchive/cls/base.py

@@ -1,16 +1,29 @@
+import json
+import typing
+
+from supabase import Client
+
 class NSID(str):
+    """
+    Nation Server ID
+
+    ID unique et universel pour l'ensemble des entités et évènements. Il prend les `int`, les `str` et les autres instances `NSID` pour les convertir en un identifiant hexadécimal.
+    """
     unknown = "0"
-    admin = "01"
-    gov = "02"
-    assembly = "03"
-    court = "04"
-    office = "05"
-    hexabank = "06"
-    archives = "07"
-
-    maintenance_committee = "101"
-    audiovisual_department = "102"
-    interior_department = "103"
+    admin = "1"
+    gov = "2"
+    court = "3"
+    assembly = "4"
+    office = "5"
+    hexabank = "6"
+    archives = "7"
+
+    maintenance_com = "101"
+    audiovisual_dept = "102"
+    interior_dept = "103"
+    justice_dept = "104"
+    egalitary_com = "105"
+    antifraud_dept = "106"
 
     def __new__(cls, value):
         if type(value) == int:
@@ -19,9 +32,156 @@ class NSID(str):
             value = hex(int(value, 16))
         else:
             raise TypeError(f"<{value}> is not NSID serializable")
-        
+
         if value.startswith("0x"):
             value = value[2:]
-        
+
         instance = super(NSID, cls).__new__(cls, value.upper())
-        return instance
+        return instance
+
+class Instance:
+    """
+    Instance qui servira de base à toutes les instances.
+    """
+    def __init__(self, client: Client):
+        self.db = client
+
+    def _select_from_db(self, table: str, key: str = None, value: str = None) -> list:
+        """
+        Récupère des données JSON d'une table Supabase en fonction de l'ID.
+
+        ## Paramètres
+        table: `str`:\n
+            Nom de la base
+        key: `str`\n
+            Clé à vérifier
+        value: `str`\n
+            Valeur de la clé à vérifier
+
+        ## Renvoie
+        - `list` de tous les élements correspondants
+        - `None` si aucune donnée n'est trouvée
+        """
+
+        if key and value:
+            res = self.db.from_(table).select("*").eq(key, value).execute()
+        else:
+            res = self.db.from_(table).select("*").execute()
+
+        if res.data:
+            return res.data
+        else:
+            return None
+
+    def _get_by_ID(self, table: str, id: NSID) -> dict:
+        _data = self._select_from_db(table, 'id', id)
+
+        if _data is not None:
+            _data = _data[0]
+
+        return _data
+
+    def _put_in_db(self, table: str, data: dict) -> None:
+        """
+        Publie des données JSON dans une table Supabase en utilisant le client Supabase.
+
+        :param table: Nom de la table dans laquelle les données doivent être insérées
+        :param data: Dictionnaire contenant les données à publier
+        :return: Résultat de l'insertion
+        """
+
+        res = self.db.from_(table).upsert(data).execute()
+
+        return res
+
+    def _delete_from_db(self, table: str, key: str, value: str):
+        """
+        Supprime un enregistrement d'une table Supabase en fonction d'une clé et de sa valeur.
+
+        ## Paramètres
+        table: `str`
+            Nom de la table dans laquelle les données doivent être supprimées
+        key: `str`
+            Clé à vérifier (par exemple "id" ou autre clé unique)
+        value: `str`
+            Valeur de la clé à vérifier pour trouver l'enregistrement à supprimer
+
+        ## Renvoie
+        - `True` si la suppression a réussi
+        - `False` si aucune donnée n'a été trouvée ou si la suppression a échoué
+        """
+
+        res = self.db.from_(table).delete().eq(key, value).execute()
+
+        return res
+
+    def _delete_by_ID(self, table: str, id: NSID):
+        res = self._delete_from_db(table, 'id', id)
+
+        return res
+
+    def fetch(self, table: str, **query: typing.Any) -> list:
+        matches = []
+
+        for key, value in query.items():
+            entity = self._select_from_db(table, key, value)
+
+            if entity is not None:
+                matches.append(entity)
+
+        if query == {}:
+            matches = [ self._select_from_db(table) ]
+
+        if not matches or (len(matches) != len(query) and query != {}):
+            return []
+
+        _res = [ item for item in matches[0] if all(item in match for match in matches[1:]) ]
+
+        return _res
+
+    def _upload_to_storage(self, bucket: str, data: bytes, path: str, overwrite: bool = False, options: dict = {'content-type': 'image/png'}) -> dict:
+        """
+        Envoie un fichier dans un bucket Supabase.
+
+        ## Paramètres
+        bucket: `str`\n
+            Nom du bucket où le fichier sera stocké
+        data: `bytes`\n
+            Données à uploader
+        path: `str`\n
+            Chemin dans le bucket où le fichier sera stocké
+
+        ## Renvoie
+        - `dict` contenant les informations de l'upload si réussi
+        - `None` en cas d'échec
+        """
+
+        options["upsert"] = json.dumps(overwrite)
+
+        if len(data) > 5 * 1000 ** 3:
+            raise ValueError("La limite d'un fichier à upload est de 1Mo")
+
+        res = self.db.storage.from_(bucket).upload(path, data, options)
+
+        if res.json().get("error"):
+            print("Erreur lors de l'upload:", res["error"])
+
+        return res
+
+    def _download_from_storage(self, bucket: str, path: str) -> bytes:
+        """
+        Télécharge un fichier depuis le stockage Supabase.
+
+        ## Paramètres
+        bucket: `str`\n
+            Nom du bucket où il faut chercher le fichier 
+        path: `str`\n
+            Chemin du fichier dans le bucket
+
+        ## Renvoie
+        - Le fichier demandé en `bytes`
+        """
+
+        res = self.db.storage.from_(bucket).download(path)
+
+        return res

nsarchive/cls/economy.py

@@ -1,38 +1,96 @@
-from nsarchive.cls.base import NSID
-from .base import *
+from .base import NSID
 
 class BankAccount:
-    def __init__(self, id: str | NSID) -> None:
+    """
+    Compte en banque d'une entité, individuelle ou collective.
+
+    ## Attributs
+    - id: `NSID`\n
+        Identifiant du compte
+    - owner: `NSID`\n
+        Identifiant du titulaire du compte
+    - amount: `int`\n
+        Somme d'argent totale sur le compte
+    - frozen: `bool`\n
+        État gelé ou non du compte
+    - bank: `NSID`\n
+        Identifiant de la banque qui détient le compte
+    - income: `int`\n
+        Somme entrante sur le compte depuis la dernière réinitialisation (tous les ~ 28 jours)
+    """
+
+    def __init__(self, id: NSID) -> None:
         self.id: NSID = NSID(id)
         self.owner: NSID = NSID(0)
         self.amount: int = 0
-        self.locked: bool = False
-        self.bank: str = "HexaBank"
+        self.frozen: bool = False
+        self.bank: NSID = NSID("6")
 
         self.income: int = 0
 
 class Item:
-    def __init__(self, id: str | NSID) -> None:
+    """
+    Article d'inventaire qui peut circuler sur le serveur
+
+    ## Attributs
+    - id: `NSID`\n
+        Identifiant de l'objet
+    - title: `str`\n
+        Nom de l'objet
+    - emoji: `str`\n
+        Emoji lié à l'objet
+    """
+
+    def __init__(self, id: NSID) -> None:
         self.id: NSID = NSID(id)
         self.title: str = "Unknown Object"
         self.emoji: str = ":light_bulb:"
 
 class Inventory:
+    """
+    Inventaire d'un membre
+
+    ## Attributs
+    - owner_id: `NSID`\n
+        ID du propriétaire de l'inventaire
+    - objects: `dict[str, NSID]`\n
+        Collection d'objets et leur quantité
+    """
+
     def __init__(self, owner_id: NSID) -> None:
         self.owner_id: NSID = NSID(owner_id)
-        self.objects: list[Item] = []
+        self.objects: dict[str, NSID] = {}
 
     def append(self, item: Item, quantity: int = 1):
-        self.objects.extend(quantity * [item])
+        if item.id in self.objects.keys():
+            self.objects[item.id] += quantity
+        else:
+            self.objects[item.id] = quantity
 
     def throw(self, item: Item, quantity: int = 1):
-        if quantity > self.objects.count(item):
-            quantity = self.objects.count(item)
-
-        for i in range(quantity):
-            self.objects.remove(item)
+        if item.id in self.objects.keys():
+            if self.objects[item.id] > quantity:
+                self.objects[item.id] -= quantity
+            else:
+                self.objects[item.id] = 0
 
 class Sale:
+    """
+    Vente mettant en jeu un objet
+
+    ## Attributs
+    - id: `NSID`\n
+        Identifiant de la vente
+    - item: `NSID`\n
+        Identifiant de l'objet mis en vente
+    - quantity: `int`\n
+        Quantité d'objets mis en vente
+    - price: `int`\n
+        Prix total du lot
+    - seller_id: `NSID`\n
+        Identifiant du vendeur
+    """
+
     def __init__(self, id: NSID, item: Item) -> None:
         self.id: NSID = NSID(id)
         self.item: NSID = NSID(item.id)