nsarchive 3.0.0a1__tar.gz → 3.0.0a2__tar.gz

{nsarchive-3.0.0a1 → nsarchive-3.0.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nsarchive
-Version: 3.0.0a1
+Version: 3.0.0a2
 Summary: API-wrapper pour récupérer des données liées à Nation
 License: GPL-3.0
 Author: happex
@@ -12,7 +12,6 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: pillow (>=10.4,<11.0)
-Requires-Dist: supabase (>=2.9.1,<3.0.0)
 Description-Content-Type: text/markdown
 
 # NSArchive

{nsarchive-3.0.0a1 → nsarchive-3.0.0a2}/nsarchive/__init__.py

@@ -1,27 +1,24 @@
 """
 nsarchive - API-wrapper pour récupérer des données liées à Nation.
 
-Version: 2.0.0
+Version: 3.0.0a2
 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 
+# Import des types 
 from .cls.base import NSID
 from .cls.archives import *
 from .cls.entities import *
 from .cls.republic import *
 from .cls.economy import *
 
-from .cls.exceptions import *
-
 # Import des instances
 from .instances._economy import EconomyInstance
 from .instances._entities import EntityInstance

nsarchive-3.0.0a2/nsarchive/cls/base.py

@@ -0,0 +1,237 @@
+import io
+import json
+import requests
+import typing
+import warnings
+
+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 = "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:
+    """
+    Instance qui servira de base à toutes les instances.
+    """
+
+    def __init__(self, url: str, token: str = None):
+        self.url = url
+        self.token = token
+
+        self.default_headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+        }
+
+    def request_token(self, username: str, password: str) -> str | None:
+        res = requests.post(f"{self.url}/auth/login", json = {
+            "username": username,
+            "password": password
+        })
+
+        if res.status_code == 200:
+            return res.json()["token"]
+        elif res.status_code in (401, 403):
+            raise PermissionError(res.json()['message'])
+        else:
+            raise Exception(f"Error {res.status_code}: {res.json()['message']}")
+
+    def _get_item(self, endpoint: str, body: dict = None, headers: dict = None) -> dict:
+        """
+        Récupère des données JSON depuis l'API
+
+        ## Paramètres
+        endpoint: `str`:
+            Endpoint de l'URL
+        headers: `dict` (optional)
+            Headers à envoyer
+        body: `dict` (optional)
+            Données à envoyer
+
+        ## Renvoie
+        - `list` de tous les élements correspondants
+        - `None` si aucune donnée n'est trouvée
+        """
+
+        if not headers:
+            headers = self.default_headers
+
+        res = requests.get(f"{self.url}/{endpoint}", headers = headers, json = body, timeout = 5)
+
+        if 200 <= res.status_code < 300:
+            return res.json()
+        elif res.status_code == 404:
+            return
+        elif res.status_code in (403, 401):
+            raise PermissionError(res.json()['message'])
+        else:
+            raise Exception(f"Error {res.status_code}: {res.json()['message']}")
+
+    def _get_by_ID(self, _class: str, id: NSID) -> dict:
+        _data = self._get_item(f"/model/{_class}/{id}")
+
+        return _data
+
+    def _put_in_db(self, endpoint: str, body: dict, headers: dict = None, use_PUT: bool = False) -> None:
+        """
+        Publie des données JSON dans une table nation-db.
+
+        ## Paramètres
+        endpoint: `str`
+            Endpoint de l'URL
+        body: `dict`
+            Données à envoyer
+        headers: `dict` (optionnel)
+            Headers à envoyer
+        """
+
+        if not headers:
+            headers = headers
+
+        if use_PUT:
+            res = requests.put(f"{self.url}/{endpoint}", headers = headers, json = body)
+        else:
+            res = requests.post(f"{self.url}/{endpoint}", headers = headers, json = body)
+
+        if 200 <= res.status_code < 300:
+            return res.json()
+        else:
+            print(res.text)
+            res.raise_for_status()
+
+    def _delete(self, _class: str, ids: list[NSID]) -> None:
+        """
+        Supprime des données JSON dans une table nation-db.
+
+        ## Paramètres
+        _class: `str`
+            Classe des entités à supprimer
+        ids: `list[NSID]`
+            ID des entités à supprimer
+        """
+
+        res = requests.post(f"{self.url}/delete_{_class}", json = { "ids": ids })
+
+        if 200 <= res.status_code < 300:
+            return res.json()
+        elif res.status_code in (403, 401):
+            raise PermissionError(res.json()['message'])
+        else:
+            raise Exception(f"Error {res.status_code}: {res.json()['message']}")
+
+    def _delete_by_ID(self, _class: str, id: NSID):
+        warnings.showwarning("Method '_delete_by_id' is deprecated. Use '_delete' instead.")
+        self._delete(_class, id)
+
+    def fetch(self, _class: str, **query: typing.Any) -> list:
+        res = requests.get(f"{self.url}/fetch/{_class}", params = query)
+
+        if res.status_code == 200:
+            matches = res.json()
+        elif res.status_code in (401, 403):
+            matches = []
+        else:
+            res.raise_for_status()
+
+        return matches
+
+
+    def _upload_file(self, bucket: str, name: str, data: bytes, overwrite: bool = False, headers: dict = None) -> dict:
+        """
+        Envoie un fichier dans un bucket nation-db.
+
+        ## Paramètres
+        bucket: `str`
+            Nom du bucket où le fichier sera stocké
+        name: `str`
+            Nom du fichier dans le drive
+        data: `bytes`
+            Données à uploader
+        overwrite: `bool` (optional)
+            Overwrite ou non
+        headers: `dict` (optional)
+            Headers à envoyer
+
+        ## Renvoie
+        - `dict` contenant les informations de l'upload si réussi
+        - `None` en cas d'échec
+        """
+
+        if not headers:
+            headers = self.default_headers
+            headers['Content-Type'] = 'image/png'
+
+        body = {
+            "name": name,
+            "overwrite": json.dumps(overwrite)
+        }
+
+        file = ("file", "image/png", data)
+
+        res = requests.put(f"{self.url}/upload_file/{bucket}", headers = headers, json = body, files = [ file ])
+
+        if res.status_code == 200:
+            return res.json()
+        elif res.status_code in (403, 401):
+            raise PermissionError(res.json()['message'])
+        elif res.status_code == 409:
+            raise FileExistsError(res.json()['message'])
+        else:
+            raise Exception(f"Error {res.status_code}: {res.json()['message']}") 
+
+    def _download_from_storage(self, bucket: str, path: str, headers: dict = None) -> bytes:
+        """
+        Télécharge un fichier depuis le stockage nation-db.
+
+        ## 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`
+        """
+
+        if not headers:
+            headers = self.default_headers
+
+        res = requests.get(f"{self.url}/drive/{bucket}/{path}", headers = headers)
+
+        if res.status_code == 200:
+            return res.json()
+        elif res.status_code in (403, 401):
+            raise PermissionError(res.json()['message'])
+        else:
+            raise Exception(f"Error {res.status_code}: {res.json()['message']}") 

nsarchive-3.0.0a2/nsarchive/cls/entities.py

@@ -0,0 +1,392 @@
+import requests
+import time
+import typing
+import urllib.parse
+
+from .base import NSID
+
+from .. import utils
+
+default_headers = {}
+
+class Permission:
+    def __init__(self, initial: str = "----"):
+        self.append: bool
+        self.manage: bool
+        self.edit: bool
+        self.read: bool
+
+        self.load(initial)
+
+    def load(self, val: str) -> None:
+        if 'a' in val: self.append = True
+        if 'm' in val: self.manage = True
+        if 'e' in val: self.edit = True
+        if 'r' in val: self.read = True
+
+class PositionPermissions:
+    """
+    Permissions d'une position à l'échelle du serveur. Certaines sont attribuées selon l'appartenance à divers groupes ayant une position précise
+    """
+
+    def __init__(self) -> None:
+        self.bank_accounts = Permission("a---") # APPEND = ouvrir un ou plusieurs comptes, MANAGE = voir les infos globales concernant les comptes en banque, EDIT = gérer des comptes en banque, READ = voir les infos d'un compte en banque individuel
+        self.bots = Permission() # APPEND = publier un message sous l'identité d'un bot, MANAGE = proposer d'héberger un bot, EDIT = changer les paramètres d'un bot, READ = /
+        self.constitution = Permission() # APPEND = laws.append, MANAGE = laws.manage, EDIT = modifier la constitution, READ = /
+        self.database = Permission() # APPEND = créer des sous-bases de données, MANAGE = gérer la abse de données, EDIT = modifier les éléments, READ = avoir accès à toutes les données sans exception
+        self.items = Permission("---r") # APPEND = vendre, MANAGE = gérer des items dont on n'est pas propriétaire (hors marketplace), EDIT = gérer des items dont on n'est pas propriétaire (dans le marketplace), READ = accéder au marketplace
+        self.laws = Permission() # APPEND = proposer un texte de loi, MANAGE = accepter ou refuser une proposition, EDIT = modifier un texte, READ = /
+        self.members = Permission("---r") # APPEND = créer des entités, MANAGE = modérer des entités (hors Discord), EDIT = modifier des entités, READ = voir le profil des entités
+        self.national_channel = Permission() # APPEND = prendre la parole sur la chaîne nationale, MANAGE = voir qui peut prendre la parole, EDIT = modifier le planning de la chaîne nationale, READ = /
+        self.organizations = Permission("---r") # APPEND = créer une nouvelle organisation, MANAGE = exécuter des actions administratives sur les organisations, EDIT = modifier des organisations, READ = voir le profil de n'importe quelle organisation
+        self.reports = Permission() # APPEND = déposer plainte, MANAGE = accépter ou refuser une plainte, EDIT = /, READ = accéder à des infos supplémentaires pour une plainte
+        self.state_budgets = Permission() # APPEND = débloquer un nouveau budget, MANAGE = gérer les budjets, EDIT = gérer les sommes pour chaque budjet, READ = accéder aux infos concernant les budgets
+        self.votes = Permission() # APPEND = déclencher un vote, MANAGE = fermer un vote, EDIT = /, READ = lire les propriétés d'un vote avant sa fermeture
+
+    def merge(self, permissions: dict[str, str] | typing.Self):
+        if isinstance(permissions, PositionPermissions):
+            permissions = permissions.__dict__
+
+        for key, val in permissions.items():
+            perm: Permission = self.__getattribute__(key)
+            perm.load(val)
+
+
+class Position:
+    """
+    Position légale d'une entité
+
+    ## Attributs
+    - name: `str`\n
+        Titre de la position
+    - id: `str`\n
+        Identifiant de la position
+    - permissions: `.PositionPermissions`\n
+        Permissions accordées à l'utilisateur
+    """
+
+    def __init__(self, id: str = 'inconnu') -> None:
+        self.name: str = "Inconnue"
+        self.id = id
+        self.permissions: PositionPermissions = PositionPermissions()
+
+    def __repr__(self):
+        return self.id
+
+class Entity:
+    """
+    Classe de référence pour les entités
+
+    ## Attributs
+    - id: `NSID`\n
+        Identifiant de l'entité
+    - name: `str`\n
+        Nom d'usage de l'entité
+    - registerDate: `int`\n
+        Date d'enregistrement de l'entité
+    - position: `.Position`\n
+        Position légale de l'entité
+    - additional: `dict`\n
+        Infos supplémentaires exploitables par les bots
+    """
+
+    def __init__(self, id: NSID) -> None:
+        self._url = "" # URL de l'entité pour une requête GET
+
+        self.id: NSID = NSID(id) # ID hexadécimal de l'entité
+        self.name: str = "Entité Inconnue"
+        self.registerDate: int = 0
+        self.position: Position = Position()
+        self.additional: dict = {}
+
+    def set_name(self, new_name: str) -> None:
+        if len(new_name) > 32:
+            raise ValueError(f"Name length mustn't exceed 32 characters.")
+
+        res = requests.post(f"{self._url}/rename?name={new_name}", headers = default_headers)
+
+        if res.status_code == 200:
+            self.name = new_name
+        else:
+            print(res.status_code)
+            res.raise_for_status()
+
+    def set_position(self, position: Position) -> None:
+        res = requests.post(f"{self._url}/change_position?position={position.id}", headers = default_headers)
+
+        if res.status_code == 200:
+            self.position = position
+        else:
+            res.raise_for_status()
+
+    def add_link(self, key: str, value: str | int) -> None:
+        if isinstance(value, str):
+            _class = "string"
+        elif isinstance(value, int):
+            _class = "integer"
+        else:
+            raise TypeError("Only strings and integers can be recorded as an additional link")
+
+        params = {
+            "link": key,
+            "value": value,
+            "type": _class
+        }
+
+        query = "&".join(f"{k}={ urllib.parse.quote(v) }" for k, v in params.items())
+
+        res = requests.post(f"{self._url}/add_link?{query}", headers = default_headers)
+
+        if res.status_code == 200:
+            self.additional[key] = value
+        else:
+            print(res.text)
+            res.raise_for_status()
+
+    def unlink(self, key: str) -> None:
+        res = requests.post(f"{self._url}/remove_link?link={urllib.parse.quote(key)}", headers = default_headers)
+
+        if res.status_code == 200:
+            del self.additional[key]
+        else:
+            res.raise_for_status()
+
+class User(Entity):
+    """
+    Entité individuelle
+
+    ## Attributs
+    - Tous les attributs de la classe `.Entity`
+    - xp: `int`\n
+        Points d'expérience de l'entité
+    - boosts: `dict[str, int]`\n
+        Ensemble des boosts dont bénéficie l'entité 
+    - votes: `list[NSID]`\n
+        Liste des votes auxquels a participé l'entité
+    """
+
+    def __init__(self, id: NSID) -> None:
+        super().__init__(NSID(id))
+
+        self.xp: int = 0
+        self.boosts: dict[str, int] = {}
+        self.groups: list[NSID] = []
+
+    def get_level(self) -> None:
+        i = 0
+        while self.xp > int(round(25 * (i * 2.5) ** 2, -2)):
+            i += 1
+
+        return i
+
+    def add_xp(self, amount: int) -> None:
+        boost = 0 if 0 in self.boosts.values() or amount <= 0 else max(list(self.boosts.values()) + [ 1 ])
+        res = requests.post(f"{self._url}/add_xp?amount={amount * boost}", headers = default_headers)
+
+        if res.status_code == 200:
+            self.xp += amount * boost
+        else:
+            res.raise_for_status()
+
+    def edit_boost(self, name: str, multiplier: int = -1) -> None:
+        res = requests.post(f"{self._url}/edit_boost?boost={name}&multiplier={multiplier}", headers = default_headers)
+
+        if res.status_code == 200:
+            if multiplier >= 0:
+                self.boosts[name] = multiplier
+            else:
+                del self.boosts[name]
+        else:
+            res.raise_for_status()
+
+class MemberPermissions:
+    """
+    Permissions d'un utilisateur à l'échelle d'un groupe
+    """
+
+    def __init__(self) -> None:
+        self.manage_organization = False # Renommer l'organisation, changer le logo
+        self.manage_shares = False # Revaloriser les actions
+        self.manage_roles = False # Changer les rôles des membres
+        self.manage_members = False # Virer quelqu'un d'une entreprise, l'y inviter
+
+    def edit(self, **permissions: bool) -> None:
+        for perm in permissions.values():
+            self.__setattr__(*perm)
+
+class GroupMember:
+    """
+    Membre au sein d'une entité collective
+
+    ## Attributs
+    - permission_level: `dict[str, int]`\n
+        Niveau d'accréditation du membre (0 = salarié, 4 = administrateur)
+    """
+
+    def __init__(self, id: NSID) -> None:
+        self.id = id
+        self.permission_level: dict = { # Échelle de permissions selon le groupe de travail
+            "general": 0 
+        }
+
+    def group_permissions(self, team: str = "general") -> MemberPermissions:
+        p = MemberPermissions()
+        team_perms = self.permission_level[team]
+
+        if team_perms >= 1: # Responsable
+            p.manage_members = True
+
+        if team_perms >= 2: # Superviseur
+            p.manage_roles = True
+
+        if team_perms >= 3: # Chef d'équipe
+            pass
+
+        if team_perms >= 4: # Directeur
+            p.manage_shares = True
+            p.manage_organization = True
+
+        return p
+
+class GroupInvite:
+    def __init__(self, id: NSID):
+        self.id: NSID = id
+        self.team: str = "general"
+        self.level: str = 0
+        self._expires: int = round(time.time()) + 604800
+
+class Share:
+    """
+    Action d'une entreprise
+
+    ## Attributs
+    - owner: `NSID`\n
+        Identifiant du titulaire de l'action
+    - price: `int`\n
+        Prix de l'action
+    """
+
+    def __getstate__(self) -> dict:
+        return {
+            "owner": self.owner,
+            "price": self.price
+        }
+
+    def __setstate__(self, state: dict):
+        self.owner: NSID = state['owner']
+        self.price: int = state['price']
+
+    def __init__(self, owner: NSID = NSID(0x0), price: int = 10):
+        self.owner: NSID = owner
+        self.price: int = price
+
+    def assign_owner(self, owner: NSID):
+        self.owner = owner
+
+    def set_price(self, price: int):
+        self.price = price
+
+class Organization(Entity):
+    """
+    Entité collective
+
+    ## Attributs
+    - Tous les attributs de la classe `.Entity`
+    - owner: `.Entity`\n
+        Utilisateur ou entreprise propriétaire de l'entité collective
+    - avatar: `bytes`\n
+        Avatar/logo de l'entité collective
+    - certifications: `dict[str, int]`\n
+        Liste des certifications et de leur date d'ajout
+    - members: `list[.GroupMember]`\n
+        Liste des membres de l'entreprise
+    - parts: `list[.Share]`\n
+        Liste des actions émises par l'entreprise
+    """
+
+    def __init__(self, id: NSID) -> None:
+        super().__init__(NSID(id))
+
+        self.owner: Entity = User(NSID(0x0))
+        self.avatar: bytes = utils.open_asset('default_avatar.png')
+
+        self.certifications: dict = {}
+        self.members: list[GroupMember] = []
+        self.invites: dict[GroupInvite] = []
+
+        self.parts: list[Share] = 50 * [ Share(self.owner.id, 0) ]
+
+    def add_certification(self, certification: str, __expires: int = 2419200) -> None:
+        res = requests.post(f"{self._url}/add_certification?name={certification}&duration={__expires}", headers = default_headers)
+
+        if res.status_code == 200:
+            self.certifications[certification] = int(round(time.time()) + __expires)
+        else:
+            res.raise_for_status()
+
+    def has_certification(self, certification: str) -> bool:
+        return certification in self.certifications.keys()
+
+    def remove_certification(self, certification: str) -> None:
+        res = requests.post(f"{self._url}/remove_certification?name={certification}", headers = default_headers)
+
+        if res.status_code == 200:
+            del self.certifications[certification]
+        else:
+            res.raise_for_status()
+
+    def invite_member(self, member: NSID, level: int = 0, team: str = "general") -> None:
+        if not isinstance(member, NSID):
+            raise TypeError("L'entrée membre doit être de type NSID")
+
+        res = requests.post(f"{self._url}/invite_member?id={member}&level={level}&team={team}", headers = default_headers)
+
+        if res.status_code == 200:
+            invite = GroupInvite(member)
+            invite.team = team
+            invite.level = level
+
+            self.invites.append(invite)
+        else:
+            res.raise_for_status()
+
+    def remove_member(self, member: GroupMember) -> None:
+        for _member in self.members:
+            if _member.id == member.id:
+                self.members.remove(_member)
+
+    def remove(self, member: GroupMember) -> None:
+        self.remove_member(member)
+
+    def set_owner(self, member: User) -> None:
+        self.owner = member
+
+    def get_members_by_attr(self, attribute: str = "id") -> list[str]:
+        return [ member.__getattribute__(attribute) for member in self.members ]
+
+    def get_shares(self, include_worth: bool = False) -> dict[str, int] | dict[str, dict[str, int]]:
+        shares = {}
+
+        for share in self.parts:
+            if include_worth:
+                if share.owner in shares.keys():
+                    shares[share.owner]['count'] += 1
+                    shares[share.owner]['worth'] += share.price
+                else:
+                    shares[share.owner] = {
+                        'count': 1,
+                        'worth': share.price
+                    }
+            else:
+                if share.owner in shares.keys():
+                    shares[share.owner] += 1
+                else:
+                    shares[share.owner] = 1
+
+        return shares
+
+    def save_avatar(self, data: bytes = None):
+        if not data:
+            return
+
+        self.avatar = data