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

nsarchive/cls/entities.py

@@ -1,10 +1,9 @@
-import io
 import time
 
 from .exceptions import *
-from .base import *
+from .base import NSID
 
-from ..utils import assets
+from .. import utils
 
 class PositionPermissions:
     """
@@ -30,21 +29,53 @@ class PositionPermissions:
         self.vote_representatives = False # Participer aux élections législatives
 
     def edit(self, **permissions: bool) -> None:
-        for perm in permissions.values():
+        for perm in permissions.items():
             self.__setattr__(*perm)
 
 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:
-    def __init__(self, id: str | NSID) -> None:
+    """
+    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.id: NSID = NSID(id) # ID hexadécimal de l'entité (ou nom dans le cas de l'entreprise)
         self.name: str = "Entité Inconnue"
         self.registerDate: int = 0
-        self.legalPosition: Position = Position()
+        self.position: Position = Position()
+        self.additional: dict = {}
 
     def set_name(self, new_name: str) -> None:
         if len(new_name) > 32:
@@ -52,11 +83,33 @@ class Entity:
 
         self.name = new_name
 
-    def set_position(self, position: str) -> None:
-        self.legalPosition = position
+    def set_position(self, position: Position) -> None:
+        self.position = position
+
+    def add_link(self, key: str, value: str | int) -> None:
+        if isinstance(value, str) or isinstance(value, int):
+            self.additional[key] = value
+
+    def unlink(self, key: str) -> None:
+        del self.additional[key]
 
 class User(Entity):
-    def __init__(self, id: str | NSID) -> None:
+    """
+    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é
+    - permissions: `.PositionPermissions`\n
+        Fusion des permissions offertes par la position et les groupes
+    - 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
@@ -64,7 +117,7 @@ class User(Entity):
         self.permissions: PositionPermissions = PositionPermissions() # Elles seront définies en récupérant les permissions de sa position
         self.votes: list[str] = []
 
-    def add_vote(self, id: str | NSID):
+    def add_vote(self, id: NSID):
         self.votes.append(NSID(id))
 
     def get_level(self) -> None:
@@ -91,51 +144,115 @@ 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():
             self.__setattr__(*perm)
 
 class GroupMember(User):
-    def __init__(self, id: str | NSID) -> None:
+    """
+    Membre au sein d'une entité collective
+
+    ## Attributs
+    - Tous les attributs de la classe `.User`
+    - permission_level: `int`\n
+        Niveau d'accréditation du membre (0 = salarié, 4 = administrateur)
+    """
+
+    def __init__(self, id: 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)
+    def group_permissions(self) -> MemberPermissions:
+        p = MemberPermissions()
 
-        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é
-        }
+        if self.permission_level >= 1:
+            p.manage_members = True
+
+        if self.permission_level >= 2:
+            p.manage_shares = True
 
-        self.contributions: dict = {
-            'project': 0,
-            'approved_project': 0, 
-            'admin_action': 0, 
-            'law_vote': 0
+        if self.permission_level >= 3:
+            p.manage_roles = True
+
+        if self.permission_level >= 4:
+            p.manage_organization = True
+
+        return p
+
+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):
-    def __init__(self, id: str | NSID) -> None:
+    """
+    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
+        self.owner: Entity = User(NSID(0x0))
+        self.avatar: bytes = utils.open_asset('default_avatar.png')
+
         self.certifications: dict = {}
         self.members: list[GroupMember] = []
-        self.avatar: bytes = assets.open('default_avatar.png')
 
-    def add_certification(self, certif: str) -> None:
-        self.certifications[certif] = round(time.time())
+        self.parts: list[Share] = 50 * [ Share(self.owner.id, 0) ]
+
+    def add_certification(self, certification: str) -> None:
+        self.certifications[certification] = round(time.time())
+
+    def has_certification(self, certification: str) -> bool:
+        return certification in self.certifications.keys()
+
+    def remove_certification(self, certification: str) -> None:
+        del self.certifications[certification]
 
     def add_member(self, member: GroupMember) -> None:
         if not isinstance(member, GroupMember):
@@ -157,5 +274,26 @@ class Organization(Entity):
     def set_owner(self, member: User) -> None:
         self.owner = member
 
-    def get_member_id(self) -> list[str]:
-        return [ member.id for member in self.members ]
+    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

nsarchive/cls/republic.py

@@ -1,32 +1,117 @@
-from nsarchive.cls.entities import NSID
-from .entities import *
+from nsarchive.cls.base import NSID
 
 # Votes
 
+class VoteOption:
+    """
+    Option disponible lors d'un vote
+
+    ## Attributs
+    - id: `str`\n
+        Identifiant de l'option
+    - title: `str`\n
+        Label de l'option
+    - count: `int`\n
+        Nombre de sympathisants pour cette option
+    """
+
+    def __init__(self, id: str, title: str = None, count: int = 0):
+        self.id = id
+        self.title = title if title else id
+        self.count = count
+
 class Vote:
-    def __init__(self, id: str | NSID, title: str, choices: tuple[str]) -> None:
+    """
+    Classe de référence pour les différents votes du serveur
+
+    ## Attributs
+    - id: `NSID`\n
+        Identifiant du vote
+    - title: `str`\n
+        Titre du vote
+    - choices: list[.VoteOption]\n
+        Liste des choix disponibles
+    - author: `NSID`\n
+        Identifiant de l'auteur du vote
+    - startDate: `int`\n
+        Date de début du vote
+    - endDate: `int`\n
+        Date limite pour voter
+    """
+
+    def __init__(self, id: NSID, title: str) -> None:
         self.id: NSID = NSID(id)
         self.title: str = title
-        self.choices = { choice : 0 for choice in choices }
-        self.author: str = '0'
+        self.choices: list[VoteOption] = []
+        self.author: NSID = NSID("0")
         self.startDate: int = 0
         self.endDate: int = 0
 
-class ClosedVote(Vote): # Meilleur nom pour cette classe en v2
-    def __init__(self, id: str | NSID, title: str) -> None:
-        super().__init__(id, title, ('yes', 'no', 'blank'))
+    def by_id(self, id: str) -> VoteOption:
+        for opt in self.choices:
+            if opt.id == id:
+                return opt
+
+    def sorted(self, titles_only: bool = False) -> list[VoteOption] | list[str]:
+        sorted_list: list[VoteOption] = sorted(self.choices, lambda opt : opt.count)
+
+        if titles_only:
+            return [ opt.id for opt in sorted_list ]
+        else:
+            return sorted_list
+
+class Referendum(Vote):
+    """
+    Vote à trois positions
+    """
+
+    def __init__(self, id: NSID, title: str) -> None:
+        super().__init__(id, title)
+
+        self.choices = [
+            VoteOption('yes', 'Oui'),
+            VoteOption('no', 'Non'),
+            VoteOption('blank', 'Pas d\'avis'),
+        ]
 
 class Lawsuit(Vote):
-    def __init__(self, id: str | NSID, title: str) -> None:
-        super().__init__(id, title, ('innocent', 'guilty', 'blank'))
+    """
+    Vote à trois positions pour un procès
+    """
+
+    def __init__(self, id: NSID, title: str) -> None:
+        super().__init__(id, title)
+
+        self.choices = [
+            VoteOption('guilty', 'Coupable'),
+            VoteOption('innocent', 'Innocent'),
+            VoteOption('blank', 'Pas d\'avis'),
+        ]
 
 
 # Institutions (defs)
 
+class Official:
+    def __init__(self, id: 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
+            'REPR': 0 # Député
+        }
+
+        self.contributions: dict = {
+            'propose_project': 0,
+            'success_project': 0, 
+            'vote_law': 0
+        }
+
 class Administration:
     def __init__(self) -> None:
         self.president: Official
-        self.members: list[Official]
+        self.members: list[Official] = []
 
 class Government:
     def __init__(self, president: Official) -> None:
@@ -39,27 +124,26 @@ class Government:
         self.press_minister: Official
         self.outer_minister: Official
 
-class Assembly:
+class Court:
     def __init__(self) -> None:
         self.president: Official
-        self.members: list[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]
+        self.members: list[Official] = []
 
 class PoliceForces:
     def __init__(self) -> None:
         self.president: Official
-        self.members: list[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