nsarchive 3.0.0a7__tar.gz → 3.0.0b1__tar.gz

{nsarchive-3.0.0a7 → nsarchive-3.0.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: nsarchive
-Version: 3.0.0a7
+Version: 3.0.0b1
 Summary: API-wrapper pour récupérer des données liées à Nation
 License: GPL-3.0
 Author: happex
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: pillow (>=10.4,<11.0)
 Requires-Dist: requests (>=2.31,<3.0)
 Description-Content-Type: text/markdown

nsarchive-3.0.0b1/nsarchive/__init__.py

@@ -0,0 +1,32 @@
+"""
+nsarchive - API-wrapper pour récupérer des données liées à Nation.
+
+Version: 3.0.0-beta.1
+Date de sortie: 2025-08-06
+License: GPL-3.0
+Auteur : happex <110610727+okayhappex@users.noreply.github.com>
+
+Dependencies:
+- Python ^3.10
+- pillow ^10.4
+
+Le fichier README.md fournit des détails supplémentaires pour l'utilisation.
+"""
+
+# Import des types 
+from .models.base import NSID
+from .models.entities import *
+from .models.economy import *
+
+from .models.republic import *
+from .models.state import *
+from .models.justice import *
+
+from .models.scale import *
+
+# Import des interfaces
+from .models.base import Interface
+from .interfaces._entities import EntityInterface
+from .interfaces._economy import EconomyInterface
+from .interfaces._state import StateInterface
+from .interfaces._justice import JusticeInterface

{nsarchive-3.0.0a7/nsarchive/instances → nsarchive-3.0.0b1/nsarchive/interfaces}/_economy.py

@@ -1,13 +1,12 @@
 import time
 
-from ..cls.base import *
-from ..cls.archives import *
-from ..cls.economy import *
+from ..models.base import *
+from ..models.economy import *
 
-from ..cls import economy # Pour les default_headers
+from ..models import economy # Pour les default_headers
 
-class EconomyInstance(Instance):
-    """Indisponible dans cette version."""
+class EconomyInterface(Interface):
+    """Interface qui vous permettra d'interagir avec les comptes en banque et les transactions économiques."""
 
     def __init__(self, url: str, token: str) -> None:
         super().__init__(url, token)
@@ -43,9 +42,7 @@ class EconomyInstance(Instance):
             return None
 
         account = BankAccount(id)
-        account._url = f"{self.url}/bank/accounts/{account.id}"
-
-        account._load(_data)
+        account._load(_data, self.url, self.default_headers)
 
         return account
 
@@ -107,9 +104,7 @@ class EconomyInstance(Instance):
             account = BankAccount(_acc["owner_id"])
 
             account.id = NSID(_acc['id'])
-            account._url = f"{self.url}/bank/accounts/{account.id}"
-
-            account._load(_acc)
+            account._load(_acc, self.url, self.default_headers)
 
             res.append(account)
 
@@ -144,9 +139,7 @@ class EconomyInstance(Instance):
             return None
 
         inventory = Inventory(id)
-        inventory._url = f"{self.url}/bank/inventories/{inventory.id}"
-
-        inventory._load(_data)
+        inventory._load(_data, self.url, self.default_headers)
 
         return inventory
 
@@ -201,9 +194,7 @@ class EconomyInstance(Instance):
             inventory = Inventory(_inv["owner_id"])
 
             inventory.id = NSID(_inv['id'])
-            inventory._url = f"{self.url}/bank/inventories/{inventory.id}"
-
-            inventory._load(_inv)
+            inventory._load(_inv, self.url, self.default_headers)
 
             res.append(inventory)
 
@@ -238,10 +229,9 @@ class EconomyInstance(Instance):
             return None
 
         item = Item()
-        item.id = id
-        item._url = f"{self.url}/marketplace/items/{item.id}"
 
-        item._load(_data)
+        item.id = id
+        item._load(_data, self.url, self.default_headers)
 
         return item
 
@@ -294,9 +284,7 @@ class EconomyInstance(Instance):
             item = Item()
 
             item.id = NSID(_item['id'])
-            item._url = f"{self.url}/marketplace/items/{item.id}"
-
-            item._load(_item)
+            item._load(_item, self.url, self.default_headers)
 
             res.append(item)
 
@@ -332,10 +320,9 @@ class EconomyInstance(Instance):
             return None
 
         sale = Sale()
-        sale.id = id
-        sale._url = f"{self.url}/marketplace/sales/{sale.id}"
 
-        sale._load(_data)
+        sale.id = id
+        sale._load(_data, self.url, self.default_headers)
 
         return sale
 
@@ -369,9 +356,7 @@ class EconomyInstance(Instance):
             sale = Sale()
 
             sale.id = NSID(_sale['id'])
-            sale._url = f"{self.url}/marketplace/sales/{sale.id}"
-
-            sale._load(_sale)
+            sale._load(_sale, self.url, self.default_headers)
 
             res.append(sale)
 

nsarchive-3.0.0b1/nsarchive/interfaces/_entities.py

@@ -0,0 +1,206 @@
+from ..models.base import *
+from ..models.entities import *
+
+from ..models import entities # Pour les default_headers
+
+class EntityInterface(Interface):
+    """
+    Interface qui vous permettra d'interagir avec les profils des membres ainsi que les différents métiers et secteurs d'activité.
+
+    ## Informations disponibles
+    - Profil des membres et des entreprises: `.User | .Organization | .Entity`
+    - Participation d'un membre à différent votes: `.User | .Organization | .Entity`
+    - Appartenance et permissions d'un membre dans un groupe: `.GroupMember.MemberPermissions`
+    - Position légale et permissions d'une entité: `.Position.Permissions`
+    - Sanctions et modifications d'une entité: `.Action[ .AdminAction | .Sanction ]`
+    """
+
+    def __init__(self, url: str, token: str = None) -> None:
+        super().__init__(url, token)
+
+    """
+    ---- ENTITÉS ----
+    """
+
+    def get_entity(self, id: NSID, _class: str = None) -> User | Organization | Entity:
+        """
+        Fonction permettant de récupérer le profil public d'une entité.\n
+
+        ## Paramètres
+        id: `NSID`
+            ID héxadécimal de l'entité à récupérer
+        _class: `str`
+            Classe du modèle à prendre (`.User` ou `.Organization`)
+
+        ## Renvoie
+        - `.User` dans le cas où l'entité choisie est un membre
+        - `.Organization` dans le cas où c'est un groupe
+        - `.Entity` dans le cas où c'est indéterminé
+        """
+
+        id = NSID(id)
+
+        if _class == "user":
+            _data = self._get_by_ID('individuals', id)
+        elif _class == "group":
+            _data = self._get_by_ID('organizations', id)
+        else:
+            _data = self._get_by_ID('entities', id)
+
+        if _data is None: # ID inexistant chez les entités
+            return None
+
+        if _data['_class'] == 'individuals':
+            entity = User(id)
+        elif _data['_class'] == 'organizations':
+            entity = Organization(id)
+        else: 
+            entity = Entity(id)
+
+        entity._load(_data, self.url, self.default_headers)
+
+        return entity
+
+    def create_entity(self, id: NSID, name: str, _class: str, position: str = 'membre', zone: int = 10):
+        """
+        Fonction permettant de créer ou modifier une entité.
+
+        ## Paramètres
+        - id (`NSID`): Identifiant NSID
+        - name (`str`): Nom d'usage
+        - _class (`"user"` ou `"group"`): Type de l'entité
+        - position (`str`, optionnel): ID de la position civile
+        - zone (`int`, optionnel): ID de la zone civile
+        """
+
+        id = NSID(id)
+
+        if _class in ('group', 'organization'):
+            _class = 'organizations'
+        elif _class in ('user', 'individual'):
+            _class = 'individuals'
+        else:
+            return
+
+        self._put_in_db(
+            f"/new_model/{_class}?id={id}&name={name}&position={position}&zone={zone}",
+            headers = self.default_headers,
+            use_PUT = True
+        )
+
+        entity = self.get_entity(id)
+
+        if _class == "individuals":
+            entity._url = f"{self.url}/model/individuals/{id}"
+        elif isinstance(entity, Organization):
+            entity._url = f"{self.url}/model/organizations/{id}"
+            entity.avatar_url = f"{entity._url}/avatar"
+        else:
+            entity._url = f"{self.url}/model/entities/{id}"
+
+        return entity
+
+
+    def delete_entity(self, entity: Entity):
+        """
+        Fonction permettant de supprimer le profil d'une entité
+
+        ## Paramètres
+        entity: `.Entity`\n
+            L'entité à supprimer
+        """
+
+        res = requests.post(f"{entity._url}/delete", headers = self.default_headers)
+
+        if res.status_code != 200:
+            res.raise_for_status()
+
+    def fetch_entities(self, **query: typing.Any) -> list[ Entity | User | Organization ]:
+        """
+        Récupère une liste d'entités en fonction d'une requête.
+
+        ## Paramètres
+        query: `**dict`\n
+            La requête pour filtrer les entités.
+
+        ## Renvoie
+        - `list[.Entity | .User | .Organization]`
+        """
+
+        if "_class" in query.keys():
+            if query["_class"] == "individuals":
+                del query["_class"]
+                _res = self.fetch('individuals', **query)
+            elif query["_class"] == "organizations":
+                del query["_class"]
+                _res = self.fetch('organizations', **query)
+            else:
+                del query["_class"]
+                _res = self.fetch('entities', **query)
+        else:
+            _res = self.fetch('entities', **query)
+
+        res = []
+
+        for _entity in _res:
+            if _entity is None: continue
+
+            if _entity['_class'] == 'individuals':
+                entity = User(_entity["id"])
+            elif _entity['_class'] == 'organizations':
+                entity = Organization(_entity["id"])
+            else:
+                entity = Entity(_entity["id"])
+
+            entity._load(_entity, self.url, self.default_headers)
+
+            res.append(entity)
+
+        return res
+
+
+
+    def get_position(self, id: str) -> Position:
+        """
+        Récupère une position légale (métier, domaine professionnel).
+
+        ## Paramètres
+        id: `str`\n
+            ID de la position (SENSIBLE À LA CASSE !)
+
+        ## Renvoie
+        - `.Position`
+        """
+
+        _data = self._get_by_ID('positions', id)
+
+        if _data is None:
+            return None
+
+        position = Position(id)
+        position._load(_data, self.url, self.default_headers)
+
+        return position
+
+    def fetch_positions(self, **query: typing.Any) -> list[Position]:
+        """
+        Récupère une liste de positions en fonction d'une requête.
+
+        ## Paramètres
+        query: `**dict`\n
+            La requête pour filtrer les positions.
+
+        ## Renvoie
+        - `list[.Position]`
+        """
+
+        _res = self.fetch('positions', **query)
+        res = []
+
+        for _data in _res:
+            pos = Position()
+            pos._load(_data, self.url, self.default_headers)
+
+            res.append(pos)
+
+        return res

nsarchive-3.0.0b1/nsarchive/interfaces/_justice.py

@@ -0,0 +1,122 @@
+import requests
+import time
+
+from ..models.base import *
+from ..models.justice import *
+
+class JusticeInterface(Interface):
+    """
+    Gère les procès, sanctions et signalements.
+    """
+
+    def __init__(self, url: str, token: str) -> None:
+        super().__init__(url, token)
+
+    """
+    SIGNALEMENTS
+    """
+
+    def get_report(self, id: NSID) -> Report:
+        res = requests.get(
+            f"{self.url}/justice/reports/{id}",
+            headers = self.default_headers,
+        )
+
+        if res.status_code != 200:
+            res.raise_for_status()
+
+        report = Report(id)
+        report._load(res.json(), f"{self.url}/justice/reports/{id}", self.default_headers)
+
+        return report
+
+    def submit_report(self, target: NSID, reason: str = None, details: str = None) -> Report:
+        payload = {}
+        if reason: payload['reason'] = reason
+        if details: payload['details'] = details
+
+        res = requests.put(
+            f"{self.url}/justice/submit_report?target={target}",
+            headers = self.default_headers,
+            json = payload
+        )
+
+        if res.status_code != 200:
+            res.raise_for_status()
+
+        report = Report(NSID(res.json()['id']))
+        report._load(res.json(), f"{self.url}/justice/reports/{report.id}", self.default_headers)
+
+        return report
+
+    """
+    PROCÈS
+    """
+
+    def get_lawsuit(self, id: NSID) -> Lawsuit:
+        res = requests.get(
+            f"{self.url}/justice/lawsuits/{id}",
+            headers = self.default_headers,
+        )
+
+        if res.status_code != 200:
+            res.raise_for_status()
+
+        lawsuit = Lawsuit(id)
+        lawsuit._load(res.json(), f"{self.url}/justice/lawsuits/{id}", self.default_headers)
+
+        return lawsuit
+
+    def open_lawsuit(self, target: NSID, title: str = None, report: Report = None) -> Lawsuit:
+        payload = {}
+        if title: payload['title'] = title
+
+        res = requests.put(
+            f"{self.url}/justice/open_lawsuit?target={target}{('&report=' + report.id) if report else ''}",
+            headers = self.default_headers,
+            json = payload
+        )
+
+        if res.status_code != 200:
+            res.raise_for_status()
+
+        lawsuit = Lawsuit(NSID(res.json()['id']))
+        lawsuit._load(res.json(), f"{self.url}/justice/lawsuits/{report.id}", self.default_headers)
+
+        return lawsuit
+
+    """
+    SANCTIONS
+    """
+
+    def get_sanction(self, id: NSID) -> Sanction:
+        res = requests.get(
+            f"{self.url}/justice/sanctions/{id}",
+            headers = self.default_headers,
+        )
+
+        if res.status_code != 200:
+            res.raise_for_status()
+
+        sanction = Sanction(id)
+        sanction._load(res.json(), f"{self.url}/justice/sanctions/{id}", self.default_headers)
+
+        return sanction
+
+    def add_sanction(self, target: NSID, _type: str, duration: int = None, title: str = None, lawsuit: Lawsuit = None) -> Sanction:
+        payload = {}
+        if title: payload['title'] = title
+
+        res = requests.put(
+            f"{self.url}/justice/add_sanction?type={_type}&target={target}&date={str(round(time.time()))}{('&duration=' + str(duration)) if duration else ''}{('&case=' + lawsuit.id) if lawsuit else ''}",
+            headers = self.default_headers,
+            json = payload
+        )
+
+        if res.status_code != 200:
+            res.raise_for_status()
+
+        sanction = Sanction(NSID(res.json()['id']))
+        sanction._load(res.json(), f"{self.url}/justice/sanctions/{sanction.id}", self.default_headers)
+
+        return sanction

nsarchive-3.0.0b1/nsarchive/interfaces/_state.py

@@ -0,0 +1,196 @@
+import time
+
+from ..models.base import *
+from ..models.republic import *
+from ..models.state import *
+from ..models.scale import *
+
+class StateInterface(Interface):
+    """
+    Gère les interactions avec les votes et les officiers.
+
+    ## Informations
+    - Liste des partis enregistrés: `.Party`
+    - Liste des élections: `.Election`
+    - Liste des officiers et candidats: `.Officer | .Candidate`
+    - Résultats des votes: `.Vote`
+    """
+
+    def __init__(self, url: str, token: str) -> None:
+        super().__init__(url, token)
+
+    """
+    ---- VOTES ----
+    """
+
+    def get_vote(self, id: NSID) -> Vote:
+        """
+        Récupère un vote.
+
+        ## Paramètres
+        id: `NSID`\n
+            ID du vote.
+
+        ## Renvoie
+        - `.Vote`
+        """
+
+        id = NSID(id)
+        res = requests.get(f"{self.url}/votes/{id}", headers = self.default_headers)
+
+        if not res:
+            return None
+
+        _data = res.json()
+
+        vote = Vote(id)
+        vote._load(_data, url = f"{self.url}/votes/{id}", headers = self.default_headers)
+
+        return vote
+
+    def open_vote(self, title: str = None, options: list[dict] = [], end: int = 0) -> Vote:
+        """
+        Déclenche un vote dans la base de données.
+
+        ## Paramètres
+        - title: `str`\n
+            Titre du vote
+        - options: list[dict]\n
+            Liste des choix disponibles
+        - end: `int`\n
+            Fin du vote (timestamp)
+        """
+
+        payload = {
+            "options": options,
+            "end_date": end
+        }
+
+        if title:
+            payload['title'] = title
+
+        res = requests.put(f"{self.url}/open_vote", headers = self.default_headers, json = payload)
+
+        if res.status_code == 200:
+            _data = res.json()
+
+            vote = Vote(_data['id'])
+            vote._load(_data, url = f"{self.url}/votes/{_data['id']}", headers = self.default_headers)
+
+            return vote
+        else:
+            res.raise_for_status()
+
+    # Aucune possibilité de supprimer un vote
+
+    def get_election(self, id: NSID) -> Election:
+        """
+        Récupère une élection.
+
+        ## Paramètres
+        id: `NSID`\n
+            ID de l'élection.
+
+        ## Renvoie
+        - `.Election`
+        """
+
+        id = NSID(id)
+        res = requests.get(f"{self.url}/elections/{id}", headers = self.default_headers)
+
+        if res.status_code != 200:
+            res.raise_for_status()
+
+        _data = res.json()
+
+        election = Election(id)
+        election._load(_data, url = f"{self.url}/elections/{id}", headers = self.default_headers)
+
+        return election
+
+    def open_election(self, vote: Vote, start: int = None, full: bool = False) -> Election:
+        """
+        Déclenche une élection dans la base de données.
+
+        ## Paramètres
+        - vote: `.Vote`\n
+            Vote associé
+        - start: `int` (optionnel)\n
+            Date de début du vote (timestamp, dure 4 jours)
+        - full: `bool` (optionnel)\n
+            Choix du type d'élections (True = présidentielles, False = législatives)
+        """
+
+        res = requests.put(f"{self.url}/open_election?vote={vote.id}&type={'full' if full else 'partial'}{('&date=' + str(start)) if start else ''}", headers = self.default_headers, json = {})
+
+        if res.status_code == 200:
+            _data = res.json()
+
+            election = Election(_data['id'])
+            election._load(_data, url = f"{self.url}/elections/{_data['id']}", headers = self.default_headers)
+
+            return election
+        else:
+            res.raise_for_status()
+
+    """
+    PARTIS
+    """
+
+    def get_party(self, id: NSID) -> Party:
+        """
+        Récupère un parti politique.
+
+        ## Paramètres
+        id: `NSID`\n
+            ID du parti.
+
+        ## Renvoie
+        - `.Party`
+        """
+
+        id = NSID(id)
+        res = requests.get(f"{self.url}/parties/{id}", headers = self.default_headers)
+
+        if res.status_code != 200:
+            res.raise_for_status()
+
+        _data = res.json()
+
+        party = Party(id)
+        party._load(_data, url = f"{self.url}/parties/{id}", headers = self.default_headers)
+
+        return party
+
+    def register_party(self, id: NSID, color: int, motto: str = None, scale: dict | Scale = {}) -> Party:
+        """
+        Enregistre un nouveau parti pour que ses députés puissent s'y présenter.
+
+        ## Paramètres
+        - id: `NSID`\n
+            ID de l'entreprise à laquelle correspond le parti
+        - color: `int`\n
+            Couleur du parti
+        - motto: `str, optional`\n
+            Devise du parti
+        - politiscales: `.Scale`\n
+            Résultats du parti au test Politiscales
+        """
+
+        payload = {
+            "color": color,
+            "motto": motto,
+            "scale": scale if isinstance(scale, dict) else scale._to_dict()
+        }
+
+        res = requests.put(f"{self.url}/register_party?candidate={id}", headers = self.default_headers, json = payload)
+
+        if res.status_code == 200:
+            _data = res.json()
+
+            party = Party(_data['org_id'])
+            party._load(_data, url = f"{self.url}/parties/{_data['org_id']}", headers = self.default_headers)
+
+            return party
+        else:
+            res.raise_for_status()