nsarchive 1.4.0__tar.gz → 2.0.0a2__tar.gz

{nsarchive-1.4.0 → nsarchive-2.0.0a2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: nsarchive
-Version: 1.4.0
-Summary: 
+Version: 2.0.0a2
+Summary: API-wrapper pour récupérer des données liées à Nation
 License: GPL-3.0
 Author: happex
 Author-email: 110610727+okayhappex@users.noreply.github.com
@@ -11,8 +11,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: deta (>=1.2,<2.0)
 Requires-Dist: pillow (>=10.4,<11.0)
+Requires-Dist: supabase (>=2.9.1,<3.0.0)
 Description-Content-Type: text/markdown
 
 # nsarchive

nsarchive-2.0.0a2/nsarchive/__init__.py

@@ -0,0 +1,27 @@
+"""
+nsarchive - API-wrapper pour récupérer des données liées à Nation.
+
+Version: 2.0.0
+License: GPL-3.0
+Auteur : happex <110610727+okayhappex@users.noreply.github.com>
+
+Dependencies:
+- Python ^3.10
+- supabase ^2.9.1
+- pillow ^10.4
+
+Le fichier README.md fournit des détails supplémentaires pour l'utilisation.
+"""
+
+# Import des types et des exceptions 
+from .cls.base import NSID
+from .cls.archives import *
+from .cls.entities import *
+from .cls.republic import *
+
+from .cls.exceptions import *
+
+# Import des instances
+from .instances._economy import EconomyInstance
+from .instances._entities import EntityInstance
+from .instances._republic import RepublicInstance

{nsarchive-1.4.0 → nsarchive-2.0.0a2}/nsarchive/cls/archives.py

@@ -2,69 +2,75 @@ import time
 
 from .base import *
 
-class Action:
+class Archive:
     def __init__(self, author: str | NSID = '0', target: str | NSID = '0') -> None:
         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):
+class Sanction(Archive):
     def __init__(self, author: str | NSID, target: str | 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):
+class Report(Archive):
     def __init__(self, author: str | NSID, target: str | NSID) -> None:
         super().__init__(author, target)
 
-        self.details: str = ""
+        self.details: dict = {
+            "reason": None,
+            "elements": [] # Liste des pièces jointes
+        }
 
 
 # Community
 
-class Election(Action):
+class Election(Archive):
     def __init__(self, author: str | NSID, target: str | 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):
+class Promotion(Archive):
     def __init__(self, author: str | NSID, target: str | NSID, position: str) -> None:
         super().__init__(author, target)
 
-        self.position: str = position
+        self.details = {
+            "position": position
+        }
 
-class Demotion(Action):
+class Demotion(Archive):
     def __init__(self, author: str | NSID, target: str | 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: str | NSID, target: str | 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-2.0.0a2/nsarchive/cls/base.py

@@ -0,0 +1,123 @@
+import typing
+
+from supabase import Client
+
+class NSID(str):
+    unknown = "0"
+    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:
+            value = hex(value)
+        elif type(value) in (str, NSID):
+            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
+
+class Instance:
+    def __init__(self, client: Client):
+        self.db = client
+
+    def _select_from_db(self, table: str, key: str, value: str) -> dict:
+        """
+        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
+        """
+
+        res = self.db.from_(table).select("*").eq(key, value).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():
+            matches.append(self._select_from_db(table, key, value))
+
+        _res = []
+
+        for item in matches[0]:
+            if all(item in sublist for sublist in matches[1:]):
+                _res.append(item)
+
+        return _res

{nsarchive-1.4.0 → nsarchive-2.0.0a2}/nsarchive/cls/economy.py

@@ -1,12 +1,11 @@
-from nsarchive.cls.base import NSID
-from .base import *
+from .base import NSID
 
 class BankAccount:
     def __init__(self, id: str | NSID) -> None:
         self.id: NSID = NSID(id)
         self.owner: NSID = NSID(0)
         self.amount: int = 0
-        self.locked: bool = False
+        self.frozen: bool = False
         self.bank: str = "HexaBank"
 
         self.income: int = 0
@@ -23,7 +22,7 @@ class Inventory:
         self.objects: list[Item] = []
 
     def append(self, item: Item, quantity: int = 1):
-        self.objects.extend(quantity * [item])
+        self.objects.extend(quantity * [ item ])
 
     def throw(self, item: Item, quantity: int = 1):
         if quantity > self.objects.count(item):

{nsarchive-1.4.0 → nsarchive-2.0.0a2}/nsarchive/cls/entities.py

@@ -1,8 +1,7 @@
-import io
 import time
 
 from .exceptions import *
-from .base import *
+from .base import NSID
 
 from ..utils import assets
 
@@ -99,9 +98,10 @@ class MemberPermissions:
     """
 
     def __init__(self) -> None:
-        self.manage_organization = False # Renommer ou changer le logo
-        self.manage_members = False # Virer quelqu'un d'une entreprise, l'y inviter, changer ses rôles
-        self.manage_roles = False # Promouvoir ou rétrograder les membres
+        self.manage_organization = False # Renommer l'organisation, changer le logo
+        self.manage_roles = False # Changer les rôles des membres
+        self.manage_shares = False # Revaloriser les actions
+        self.manage_members = False # Virer quelqu'un d'une entreprise, l'y inviter
 
     def edit(self, **permissions: bool) -> None:
         for perm in permissions.values():
@@ -111,36 +111,38 @@ class GroupMember(User):
     def __init__(self, id: str | NSID) -> None:
         super().__init__(id)
 
-        self.group_permissions: MemberPermissions = MemberPermissions()
-        self.group_position: str = 'membre'
+        self.permission_level: int = 0
 
-class Official:
-    def __init__(self, id: str | NSID) -> None:
-        self.id: NSID = NSID(id)
-
-        self.mandates: int = {
-            'PRE_REP': 0, # Président de la République
-            'MIN': 0, # Différents ministres
-            'PRE_AS': 0, # Président de l'Assemblée Nationale
-            'JUDGE': 0, # Juge
-            'REPR': 0 # Député
-        }
+    def group_permissions(self) -> MemberPermissions:
+        p = MemberPermissions()
 
-        self.contributions: dict = {
-            'project': 0,
-            'approved_project': 0, 
-            'admin_action': 0, 
-            'law_vote': 0
-        }
+        if self.permission_level >= 1:
+            p.manage_members = True
+
+        if self.permission_level >= 2:
+            p.manage_shares = True
+
+        if self.permission_level >= 3:
+            p.manage_roles = True
+
+        if self.permission_level >= 4:
+            p.manage_organization = True
+
+        return p
 
 class Organization(Entity):
     def __init__(self, id: str | NSID) -> None:
         super().__init__(NSID(id))
 
         self.owner: Entity
+        self.avatar: bytes = assets.open('default_avatar.png')
+
         self.certifications: dict = {}
         self.members: list[GroupMember] = []
-        self.avatar: bytes = assets.open('default_avatar.png')
+
+        self.parts: dict[NSID, int] = {
+            self.owner.id: 1
+        }
 
     def add_certification(self, certification: str) -> None:
         self.certifications[certification] = round(time.time())

{nsarchive-1.4.0 → nsarchive-2.0.0a2}/nsarchive/cls/republic.py

@@ -1,5 +1,4 @@
-from nsarchive.cls.entities import NSID
-from .entities import *
+from nsarchive.cls.base import NSID
 
 # Votes
 
@@ -23,6 +22,25 @@ class Lawsuit(Vote):
 
 # Institutions (defs)
 
+class Official:
+    def __init__(self, id: str | NSID) -> None:
+        self.id: NSID = NSID(id)
+
+        self.mandates: int = {
+            'PRE_REP': 0, # Président de la République
+            'MIN': 0, # Différents ministres
+            'PRE_AS': 0, # Président de l'Assemblée Nationale
+            'JUDGE': 0, # Juge
+            'REPR': 0 # Député
+        }
+
+        self.contributions: dict = {
+            'project': 0,
+            'approved_project': 0, 
+            'admin_action': 0, 
+            'law_vote': 0
+        }
+
 class Administration:
     def __init__(self) -> None:
         self.president: Official
@@ -39,15 +57,15 @@ class Government:
         self.press_minister: Official
         self.outer_minister: Official
 
-class Assembly:
+class Court:
     def __init__(self) -> None:
         self.president: Official
+        # On discutera de la mise en place d'un potentiel président. Pour l'instant c'est le Ministre de la Justice
         self.members: list[Official]
 
-class Court:
+class Assembly:
     def __init__(self) -> None:
         self.president: Official
-        # On discutera de la mise en place d'un potentiel président. Pour l'instant c'est le Ministre de la Justice
         self.members: list[Official]
 
 class PoliceForces:
@@ -55,11 +73,10 @@ class PoliceForces:
         self.president: Official
         self.members: list[Official]
 
-class Institutions:
+class State:
     def __init__(self) -> None:
         self.administration: Administration
         self.government: Government
         self.court: Court
         self.assembly: Assembly
-        self.police: PoliceForces
-
+        self.police: PoliceForces

nsarchive-2.0.0a2/nsarchive/instances/_economy.py

@@ -0,0 +1,248 @@
+import time
+
+from supabase import create_client
+
+from ..cls.base import *
+from ..cls.archives import *
+from ..cls.economy import *
+
+from ..cls.exceptions import *
+
+class EconomyInstance(Instance):
+    """Gère les interactions avec les comptes bancaires, les transactions, et le marché."""
+
+    def __init__(self, id: str, token: str) -> None:
+        super().__init__(create_client(f"https://{id}.supabase.co", token))
+
+    """
+    ---- COMPTES EN BANQUE ----
+    """
+
+    def get_account(self, id: str | NSID) -> BankAccount:
+        """
+        Récupère les informations d'un compte bancaire.
+
+        ## Paramètres
+        id: `str | NSID`\n
+            ID du compte.
+
+        ## Renvoie
+        - `.BankAccount`
+        """
+
+        id = NSID(id)
+        _data = self._get_by_ID('accounts', id)
+
+        if _data is None:
+            return None
+
+        account = BankAccount(id)
+        account.amount = _data['amount']
+        account.frozen = _data['frozen']
+        account.owner = _data['owner_id']
+        account.bank = _data['bank']
+
+        return account
+
+    def save_account(self, account: BankAccount):
+        """Sauvegarde un compte bancaire dans la base de données."""
+
+        _data = {
+            'id': NSID(account.id),
+            'amount': account.amount,
+            'frozen': account.frozen, 
+            'owner_id': account.owner, 
+            'bank': account.bank
+        }
+
+        self._put_in_db('accounts', _data)
+
+    def freeze_account(self, account: BankAccount):
+        """Gèle un compte bancaire pour empêcher toute transaction."""
+
+        account.id = NSID(account.id)
+        account.frozen = True
+
+        self.save_account(account)
+
+    """
+    ---- VENTES ----
+    """
+
+    def get_sale(self, id: str | NSID) -> Sale | None:
+        """
+        Récupère une vente disponible sur le marketplace.
+
+        ## Paramètres
+        id: `str | NSID`\n
+            ID de l'item.
+
+        ## Renvoie
+        - `.Item | None`
+        """
+
+        id = NSID(id)
+
+        _data = self._get_by_ID('market', id)
+
+        if _data is None:
+            return None
+
+        sale = Sale(NSID(id))
+        sale.__dict__ = _data
+
+        return sale
+
+    def sell_item(self, item: Item, quantity: int, price: int, seller: NSID) -> None:
+        """
+        Vend un item sur le marché.
+
+        ## Paramètres
+        item: `.Item`\n
+            Item à vendre
+        quantity: `int`\n
+            Nombre d'items à vendre
+        price: `int`\n
+            Prix à l'unité de chaque objet
+        seller: `NSID`\n
+            ID de l'auteur de la vente
+        """
+
+        sale = Sale(NSID(round(time.time()) * 16 ** 3), item)
+        sale.quantity = quantity
+        sale.price = price
+        sale.seller_id = seller
+
+        _data = sale.__dict__.copy()
+
+        self._put_in_db('market', _data)
+
+    def delete_sale(self, sale: Sale) -> None:
+        """Annule une vente sur le marketplace."""
+
+        sale.id = NSID(sale.id)
+        self._delete_by_ID('market', NSID(sale.id))
+
+    """
+    ---- INVENTAIRES ----
+    """
+
+    def get_inventory(self, id: NSID) -> Inventory | None:
+        """
+        Récupérer un inventaire dans la base des inventaires.
+
+        ## Paramètres
+        id: `NSID`\n
+            ID du propriétaire de l'inventaire
+
+        ## Retourne
+        - `.Inventory | None`
+        """
+
+        _data = self._get_by_ID('inventories', id)
+
+        if _data is None:
+            return None
+
+        inventory = Inventory(id)
+
+        for _item in _data['objects']:
+            item = Item(_item['id'])
+            item.__dict__ = _item
+
+            inventory.objects.append(item)
+
+        return inventory
+
+    def save_inventory(self, inventory: Inventory) -> None:
+        """
+        Sauvegarder un inventaire
+
+        ## Paramètres
+        inventory: `.Inventory`\n
+            Inventaire à sauvegarder
+        """
+
+        _data = {
+            "owner_id": inventory.owner_id,
+            "objects": [ object.__dict__ for object in inventory.objects ]
+        }
+
+        self._put_in_db('inventories', _data)
+
+    def delete_inventory(self, inventory: Inventory) -> None:
+        """
+        Supprime un inventaire
+
+        ## Paramètres
+        inventory: `.Inventory`
+            Inventaire à supprimer
+        """
+
+        self._delete_by_ID('inventories', inventory.owner_id)
+
+    """
+    ---- ARCHIVES ----
+    """
+
+    def _add_archive(self, archive: Archive):
+        """Ajoute une archive d'une transaction ou d'une vente dans la base de données."""
+
+        archive.id = NSID(archive.id)
+        archive.author = NSID(archive.author)
+        archive.target = NSID(archive.target)
+
+        _data = archive.__dict__.copy()
+
+        if type(archive) == Transaction:
+            _data['_type'] = "transaction"
+        else:
+            _data['_type'] = "unknown"
+
+        self._put_in_db('archives', _data)
+
+    def _get_archive(self, id: str | NSID) -> Archive | Transaction:
+        """
+        Récupère une archive spécifique.
+
+        ## Paramètres
+        id: `str | NSID`\n
+            ID de l'archive.
+
+        ## Renvoie
+        - `.Archive | .Transaction`
+        """
+
+        id = NSID(id)
+        _data = self._get_by_ID('archives', id)
+
+        if _data is None:
+            return None
+
+        if _data['_type'] == "transaction":
+            archive = Transaction(_data['author'], _data['target'])
+        else:
+            archive = Archive(_data['author'], _data['target'])
+
+        archive.id = id
+        archive.action = _data['action']
+        archive.date = _data['date']
+        archive.details = _data['details']
+
+        return archive
+
+    def _fetch_archives(self, **query) -> list[ Archive | Transaction ]:
+        """
+        Récupère une liste d'archives correspondant à la requête.
+
+        ## Paramètres
+        query: `dict`\n
+            Requête pour filtrer les archives.
+
+        ## Renvoie
+        - `list[.Archive | .Transaction]`
+        """
+
+        _res = self.fetch('archives', **query)
+
+        return [ self._get_archive(archive['id']) for archive in _res ]