nsarchive 3.0.0a6__tar.gz → 3.0.0a8__tar.gz

{nsarchive-3.0.0a6 → nsarchive-3.0.0a8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: nsarchive
-Version: 3.0.0a6
+Version: 3.0.0a8
 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.0a8/nsarchive/__init__.py

@@ -0,0 +1,30 @@
+"""
+nsarchive - API-wrapper pour récupérer des données liées à Nation.
+
+Version: 3.0.0-alpha.8
+Date de sortie: 2025-08-04
+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 *
+
+# 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.0a6/nsarchive/instances → nsarchive-3.0.0a8/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.0a8/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={urllib.parse.quote(id)}&name={urllib.parse.quote(name)}&position={urllib.parse.quote(position)}&zone={urllib.parse.quote(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.0a8/nsarchive/interfaces/_justice.py

@@ -0,0 +1,50 @@
+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

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

@@ -0,0 +1,142 @@
+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, _data['title'])
+        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 = _data)
+
+        if res.status_code == 200:
+            _data = res.json()
+
+            vote = Vote()
+            vote._load(_data, url = f"{self.url}/votes/{_data['id']}", headers = self.default_headers)
+        else:
+            res.raise_for_status()
+
+    # Aucune possibilité de supprimer un vote
+
+    """
+    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 not res:
+            return None
+
+        _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
+        }
+
+        res = requests.put(f"{self.url}/register_party?candidate={id}", headers = self.default_headers, json = _data)
+
+        if res.status_code == 200:
+            _data = res.json()
+
+            vote = Vote()
+            vote._load(_data, url = f"{self.url}/votes/{_data['id']}", headers = self.default_headers)
+        else:
+            res.raise_for_status()

nsarchive-3.0.0a8/nsarchive/mandate.py

@@ -0,0 +1,50 @@
+import math
+import time
+
+EPOCH = 1577833200 # 1er Janvier 2020
+PATIENTAGE_DATE = 1725141600 # 1er Septembre 2024
+OPEN_DATE = 1756677600 # 1er Septembre 2025
+
+MANDATE_DURATION = 2419200
+
+def get_cycle(ts: int = round(time.time())):
+    if EPOCH <= ts < PATIENTAGE_DATE:
+        return 0
+    elif PATIENTAGE_DATE <= ts < OPEN_DATE:
+        return 1
+    elif OPEN_DATE <= ts:
+        return math.floor((ts - OPEN_DATE) / MANDATE_DURATION) + 2
+    else:
+        raise ValueError(f"Timestamp {ts} is out of range (must be greater than or equal to {EPOCH}).")
+
+def get_day(ts: int = round(time.time())) -> int:
+    cycle = get_cycle(ts)
+
+    if cycle == 0:
+        return math.floor((ts - EPOCH) / 86400)
+    elif cycle == 1:
+        return math.floor((ts - PATIENTAGE_DATE) / 86400)
+    else:
+        return math.floor(((ts - OPEN_DATE) % MANDATE_DURATION) / 86400)
+
+def get_phase(ts: int = round(time.time())) -> str:
+    cycle = get_cycle(ts)
+
+    if cycle < 2: # Les deux premiers cycles durent (beaucoup) plus longtemps qu'un cycle normal.
+        return 'undefined'
+
+    day = get_day(ts)
+
+    if day == 0:
+        return 'investiture' # Investiture du PR
+    elif 1 <= day < 24:
+        return 'paix' # Rien du tout
+    elif 24 <= day < 28:
+        return 'partials' # Élections législatives
+    elif 28 <= day < 52:
+        return 'paix' # Toujours rien
+    elif 52 <= day < 56:
+        return 'elections' # Élections législatives et présidentielles
+
+    else:
+        raise ValueError(f"Idk what happened but it seems that {day} is greater than 55...")

{nsarchive-3.0.0a6/nsarchive/cls → nsarchive-3.0.0a8/nsarchive/models}/base.py

@@ -1,4 +1,3 @@
-import io
 import json
 import requests
 import typing
@@ -40,17 +39,18 @@ class NSID(str):
         if value.startswith("0x"):
             value = value[2:]
 
-        instance = super(NSID, cls).__new__(cls, value.upper())
-        return instance
+        interface = super(NSID, cls).__new__(cls, value.upper())
+        return interface
 
-class Instance:
+class Interface:
     """
-    Instance qui servira de base à toutes les instances.
+    Instance qui servira de base à toutes les interfaces.
     """
 
     def __init__(self, url: str, token: str = None):
         self.url = url
         self.token = token
+        self.zone = 20 # 10 = Serveur test, 20 = Serveur principal, 30 = Serveur de patientage, 40 = Scratch World
 
         self.default_headers = {
             "Authorization": f"Bearer {self.token}",
@@ -71,6 +71,24 @@ class Instance:
         except:
             utils.warn("NationDB is not responding.")
 
+    def alias(self, alias: NSID) -> typing.Self:
+        """
+        Duplique l'interface en se faisant passer pour une autre entité. Aucune erreur ne sera levée si l'entité n'existe pas (hormis les éventuels 401 ou 404 renvoyés par le serveur).
+
+        ## Paramètres
+        alias: `NSID`\n
+            ID de l'entité à simuler
+
+        ## Renvoie
+        - `self` avec le token de l'alias
+        """
+
+        alias = NSID(alias)
+
+        token = self.token + ':' + str(alias)
+
+        return self.__class__(self.url, token)
+
     def request_token(self, username: str, password: str) -> str | None:
         res = requests.post(f"{self.url}/auth/login", json = {
             "username": username,