nsarchive 0.1a0__py3-none-any.whl → 0.1b0__py3-none-any.whl

nsarchive/__init__.py

@@ -3,75 +3,409 @@ import time
 import deta
 
 from .cls.entities import *
+from .cls.archives import *
+from .cls.republic import *
+from .cls.bank import *
+
 from .cls.exceptions import *
 
 class EntityInstance:
     def __init__(self, token: str) -> None:
         self.db = deta.Deta(token)
         self.base = self.db.Base('entities')
+        self.electors = self.db.Base('electors')
+        self.archives = self.db.Base('archives')
+        self.avatars = self.db.Drive('avatars')
 
     def get_entity(self, id: str) -> User | Organization | Entity:
-        _base = self.base
-        _data = _base.get(id)
+        id = id.upper()
+        _data = self.base.get(id)
 
         if _data is None:
             return Entity("0")
 
         if _data['_type'] == 'user':
             entity = User(id)
+
+            entity.xp = _data['xp']
+            entity.boosts = _data['boosts']
         elif _data['_type'] == 'organization':
             entity = Organization(id)
+
+            entity.owner = self.get_entity(_data['owner_id'].upper())
+            entity.members = [
+                self.get_entity(_id) for _id in _data['members']
+            ]
+
+            entity.avatar = self.avatars.get(id).read()
+
+            entity.certifications = _data['certifications']
         else:
             entity = Entity(id)
 
         entity.name = _data['name']
         entity.legalPosition = _data['legalPosition'] # Métier si c'est un utilisateur, domaine professionnel si c'est un collectif
         entity.registerDate = _data['registerDate']
-        entity.xp = _data['xp']
-
-        if type(entity) == Organization:
-            entity.owner = self.get_entity(_data['owner_id'])
-            entity.members = [
-                self.get_entity(_id) for _id in _data['members']
-            ]
 
-            entity.certifications = _data['certifications']
-        elif type(entity) == User:
-            entity.boosts = _data['boosts']
-        
         return entity
-    
+
     def save_entity(self, entity: Entity) -> None:
         _base = self.base
         _data = {
             '_type': 'user' if type(entity) == User else 'organization' if type(entity) == Organization else 'unknown',
             'name': entity.name,
             'legalPosition': entity.legalPosition,
-            'registerDate': entity.registerDate,
-            'xp': entity.xp
+            'registerDate': entity.registerDate
         }
 
         if type(entity) == Organization:
-            _data['owner_id'] = entity.owner.id if entity.owner else Entity(0)
-            _data['members'] = [ member.id for member in entity.members ] if entity.members else []
+            _data['owner_id'] = entity.owner.id.upper() if entity.owner else "0"
+            _data['members'] = [ member.id.upper() for member in entity.members ] if entity.members else []
             _data['certifications'] = entity.certifications
+
+            self.avatars.put(name = entity.id, data = entity.avatar)
         elif type(entity) == User:
+            _data['xp'] = entity.xp
             _data['boosts'] = entity.boosts
 
-        _base.put(_data, entity.id, expire_in = 3 * 31536000) # Données supprimées tous les trois ans
+        _base.put(_data, entity.id.upper(), expire_in = 3 * 31536000) # Données supprimées tous les trois ans
+    
+    def delete_entity(self, entity: Entity) -> None:
+        self.base.delete(entity.id.upper())
+
+        if type(entity) == Organization:
+            self.avatars.delete(entity.id.upper())
+
+    def get_elector(self, id: str) -> Elector:
+        id = id.upper()
+        _data = self.electors.get(id)
+
+        if _data is None:
+            self.save_elector(Elector(id))
+            return Elector(id)
+        
+        elector = Elector(id)
+        elector.votes = _data['votes']
+        
+        return elector
+
+    def save_elector(self, elector: Elector):
+        _data = {
+            "votes": elector.votes
+        }
+
+        self.electors.put(_data, elector.id.upper())
+    
+    # Les archives ne permettent pas de garder une trace des votes
+    # Donc je préfère aucune fonction permettant de les supprimer
 
-    def fetch(self, query = None, listquery: dict | None = None) -> list:
+    def fetch_entities(self, query = None, listquery: dict | None = None) -> list[Entity | User | Organization]:
         _res = self.base.fetch(query).items
 
         if listquery is not None:
             for item in _res:
-                for target, value in listquery:
+                for target, value in listquery.items():
                     if value not in item[target]:
                         _res.remove(item)
         
-        return _res
+        return [ self.get_entity(entity['key']) for entity in _res ]
+
+    def get_entity_groups(self, id: str) -> list[Organization]:
+        groups = self.fetch_entities({'_type': 'organization'}, {'members': id})
+        
+        return [ self.get_entity(group['key']) for group in groups ]
+    
+    def _add_archive(self, archive: Action):
+        _data = archive.__dict__.copy()
+
+        if type(archive) == Sanction:
+            _data['type'] = "sanction"
+        elif type(archive) == AdminAction:
+            _data['type'] = "adminaction"
+        else:
+            _data['type'] = "unknown"
+        
+        del _data['id']
+
+        self.archives.put(key = archive.id, data = _data)
+
+    def _get_archive(self, id: str) -> Action | Sanction | AdminAction:
+        _data = self.archives.get(id)
+
+        if _data is None:
+            return None
+        
+        if _data['type'] == "sanction": # Mute, ban, GAV, kick, détention, prune (xp seulement)
+            archive = Sanction(_data['author'], _data['target'])
+
+            archive.details = _data['details']
+            archive.major = _data['major']
+            archive.duration = _data['duration']
+        elif _data['type'] == "adminaction": # Renommage, promotion, démotion (au niveau de l'état)
+            archive = AdminAction(_data['author'], _data['target'])
+
+            archive.details = _data['details']
+            archive.new_state = _data['new_state']
+        else:
+            archive = Action(_data['author'], _data['target'])
+        
+        archive.id = id
+        archive.action = _data['action']
+        archive.date = _data['date']
+
+        return archive
+    
+    def _fetch_archives(self, **query) -> list[ Action | Sanction | AdminAction ]:
+        _res = self.archives.fetch(query).items
+        
+        return [ self._get_archive(archive['key']) for archive in _res ]
+    
+class RepublicInstance:
+    def __init__(self, token: str) -> None:
+        self.db = deta.Deta(token)
+        self.votes = self.db.Base('votes')
+        self.archives = self.db.Base('archives')
+        self.mandate = self.db.Base('mandate')
+        self.functions = self.db.Base('functions') # Liste des fonctionnaires
+
+    def get_vote(self, id: str) -> Vote | ClosedVote:
+        id = id.upper()
+        _data = self.votes.get(id)
+
+        if _data is None:
+            return None
+        
+        if _data['_type'] == 'open':
+            vote = Vote(id, _data['title'], tuple(_data['choices'].keys()))
+        elif _data['_type'] == 'closed':
+            vote = ClosedVote(id, _data['title'])
+        else:
+            vote = Vote('0', 'Unknown Vote', ())
+        
+        vote.author = _data['author']
+        vote.startDate = _data['startDate']
+        vote.endDate = _data['endDate']
+        vote.choices = _data['choices']
+        
+        return vote
+
+    def save_vote(self, vote: Vote | ClosedVote):
+        _data = {
+            '_type': 'open' if type(vote) == Vote else 'closed' if type(vote) == ClosedVote else 'unknown',
+            'title': vote.title,
+            'author': vote.author,
+            'startDate': vote.startDate,
+            'endDate': vote.endDate,
+            'choices': vote.choices
+        }
+
+        self.votes.put(_data, vote.id.upper())
+
+    def get_official(self, id: str, current_mandate: bool = True) -> FunctionalUser:
+        archives = self.mandate if current_mandate else self.archives
+
+        _contributions = archives.fetch({'author': id, 'type': 'contrib'}).items
+        _mandates = archives.fetch({'target': id, 'type': 'election'}).items()\
+                    + archives.fetch({'target': id, 'type': 'promotion'}).items()
+
+        user = FunctionalUser(id)
+        for mandate in _mandates:
+            if mandate['position'].startswith('MIN'): mandate['position'] = 'MIN'
+
+            try:
+                user.mandates[mandate['position']] += 1
+            except KeyError:
+                user.mandates[mandate['position']] = 1
+        
+        for contrib in _contributions:
+            try:
+                user.contributions[contrib['action']] += 1
+            except KeyError:
+                user.contributions[contrib['action']] = 1
+        
+        return user
+
+    def get_institutions(self) -> Organization:
+        admin = Administration()
+        gov = Government(FunctionalUser('0'))
+        assembly = Assembly()
+        court = Court()
+        police_forces = PoliceForces()
+        
+        _admins = self.functions.get('ADMIN')
+        admin.members = [ self.get_official(user) for user in _admins['users'] ]
+        admin.president = self.get_official('F7DB60DD1C4300A') # happex (remplace Kheops pour l'instant)
+
+        gov.president = self.get_official(self.functions.get('PRE_REP')['users'][0])
+
+        minister = lambda code : self.get_official(self.functions.get(f'MIN_{code}')['users'][0])
+        gov.prime_minister = minister('PRIM')
+        gov.economy_minister = minister('ECO')
+        gov.inner_minister = minister('INN')
+        gov.press_minister = minister('AUD')
+        gov.justice_minister = minister('JUS')
+        gov.outer_minister = minister('OUT')
+
+        assembly.president = self.get_official(self.functions.get('PRE_AS')['users'][0])
+        assembly.members = [ self.get_official(id) for id in self.functions.get('REPR')['users'] ]
+
+        court.president = gov.justice_minister
+        court.members = [ self.get_official(id) for id in self.functions.get('JUDGE')['users'] ]
+
+        police_forces.president = gov.inner_minister
+        police_forces.members = [ self.get_official(id) for id in self.functions.get('POLICE')['users'] ]
+
+        instits = Institutions()
+        instits.administration = admin
+        instits.government = gov
+        instits.court = court
+        instits.assembly = assembly
+        instits.police = police_forces
+
+        return instits
+    
+    def update_institutions(self, institutions: Institutions):
+        get_ids = lambda institution : [ member.id for member in institutions.__getattribute__(institution).members ]
+
+        self.functions.put(key = 'ADMIN', data = { 'users': get_ids('administration') })
+        self.functions.put(key = 'REPR', data = { 'users': get_ids('assembly') })
+        self.functions.put(key = 'JUDGE', data = { 'users': get_ids('court') })
+        self.functions.put(key = 'POLICE', data = { 'users': get_ids('police') })
+
+        self.functions.put(key = 'PRE_AS', data = { 'users': [ institutions.assembly.president.id ] })
+        self.functions.put(key = 'PRE_REP', data = { 'users': [ institutions.government.president.id ] })
+
+        self.functions.put(key = 'MIN_PRIM', data = { 'users': [ institutions.government.prime_minister.id ] })
+        self.functions.put(key = 'MIN_INN', data = { 'users': [ institutions.government.inner_minister.id ] })
+        self.functions.put(key = 'MIN_JUS', data = { 'users': [ institutions.government.justice_minister.id ] })
+        self.functions.put(key = 'MIN_ECO', data = { 'users': [ institutions.government.economy_minister.id ] })
+        self.functions.put(key = 'MIN_AUD', data = { 'users': [ institutions.government.press_minister.id ] })
+        self.functions.put(key = 'MIN_OUT', data = { 'users': [ institutions.government.outer_minister.id ] })
+
+    def new_mandate(self, institutions: Institutions, weeks: int = 4):
+        for item in self.mandate.fetch().items():
+            if item['date'] >= round(time.time()) - weeks * 604800:
+                self.mandate.delete(item['id'])
+        
+        self.update_institutions(institutions)
+
+    def _add_archive(self, archive: Action):
+        _data = archive.__dict__.copy()
+
+        if type(archive) == Election:
+            _data['type'] = "election"
+        elif type(archive) == Promotion:
+            _data['type'] = "promotion"
+        elif type(archive) == Demotion:
+            _data['type'] = "demotion"
+        else:
+            _data['type'] = "unknown"
+        
+        del _data['id']
+
+        self.archives.put(key = archive.id, data = _data)
+
+    def _get_archive(self, id: str) -> Action | Election | Promotion | Demotion:
+        _data = self.archives.get(id)
+
+        if _data is None:
+            return None
+        
+        if _data['type'] == "election":
+            archive = Election(_data['author'], _data['target'], _data['position'])
+
+            archive.positive_votes = _data['positive_votes']
+            archive.total_votes = _data['total_votes']
+        elif _data['type'] == "promotion":
+            archive = Promotion(_data['author'], _data['target'], _data['position'])
+        elif _data['type'] == "demotion":
+            archive = Demotion(_data['author'], _data['target'])
+
+            archive.reason = _data['reason']
+        else:
+            archive = Action(_data['author'], _data['target'])
+        
+        archive.id = id
+        archive.action = _data['action']
+        archive.date = _data['date']
+
+        return archive
+    
+    def _fetch_archives(self, **query) -> list[ Action | Election | Promotion | Demotion ]:
+        _res = self.archives.fetch(query).items
+        
+        return [ self._get_archive(archive['key']) for archive in _res ]
+
+class BankInstance:
+    def __init__(self, token: str) -> None:
+        self.db = deta.Deta(token)
+        self.archives = self.db.Base('archives')
+        self.accounts = self.db.Base('accounts')
+        self.registry = self.db.Base('banks')
+
+    def get_account(self, id: str) -> BankAccount:
+        id = id.upper()
+        _data = self.accounts.get(id)
+
+        if _data is None:
+            return None
+        
+        acc = BankAccount(id)
+        acc.amount = _data['amount']
+        acc.locked = _data['locked']
+        acc.owner = _data['owner_id']
+        acc.bank = _data['bank']
+
+        return acc
+
+    def save_account(self, acc: BankAccount):
+        _data = {
+            'amount': acc.amount,
+            'locked': acc.locked, 
+            'owner_id': acc.owner, 
+            'bank': acc.bank
+        }
+
+        self.accounts.put(_data, acc.id.upper())
+    
+    def lock_account(self, acc: BankAccount):
+        acc.locked = True
+
+        self.save_account(acc)
+
+    def _add_archive(self, _archive: Action):
+        _data = _archive.__dict__.copy()
+
+        if type(_archive) == Transaction:
+            _data['type'] = "transaction"
+        else:
+            _data['type'] = "unknown"
+        
+        del _data['id']
+
+        self.archives.put(key = _archive.id, data = _data)
+
+    def _get_archive(self, id: str) -> Action | Transaction:
+        _data = self.archives.get(id)
+
+        if _data is None:
+            return None
+        
+        if _data['type'] == "transaction":
+            archive = Transaction(_data['author'], _data['target'], _data['amount'])
+
+            archive.reason = _data['reason']
+            archive.currency = _data['currency']
+        else:
+            archive = Action(_data['author'], _data['target'])
+        
+        archive.id = id
+        archive.action = _data['action']
+        archive.date = _data['date']
+
+        return archive
     
-    def get_entity_groups(self, id: int) -> list[Organization]:
-        groups = self.fetch({'_type': 'organization'}, {'members': str(id)})
+    def _fetch_archives(self, **query) -> list[ Action | Transaction ]:
+        _res = self.archives.fetch(query).items
         
-        return [ self.get_entity(int(group['id'], 16)) for group in groups ]
+        return [ self._get_archive(archive['key']) for archive in _res ]

nsarchive/cls/archives.py

@@ -0,0 +1,60 @@
+import time
+
+class Action:
+    def __init__(self, author: str = '11625D9061021010', target: str = '0') -> None:
+        self.id: str = hex(round(time.time()))[2:].upper()
+        self.date: int = int(self.id, 16)
+        self.action: str = ""
+        self.author: str = author
+        self.target: str = target
+
+
+# Entities
+
+class Sanction(Action):
+    def __init__(self, author: str, target: str) -> 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
+
+class AdminAction(Action):
+    def __init__(self, author: str, target: str) -> None:
+        super().__init__(author, target)
+
+        self.details: str = ""
+        self.new_state: str | int | bool = None
+
+
+# Community
+
+class Election(Action):
+    def __init__(self, author: str, target: str, position: str) -> None:
+        super().__init__(author, target)
+
+        self.position: str = position
+        self.positive_votes: int = 0
+        self.total_votes: int = 0
+
+class Promotion(Action):
+    def __init__(self, author: str, target: str, position: str) -> None:
+        super().__init__(author, target)
+
+        self.position: str = position
+
+class Demotion(Action):
+    def __init__(self, author: str, target: str) -> None:
+        super().__init__(author, target)
+
+        self.reason: str = None
+
+# Bank
+
+class Transaction(Action):
+    def __init__(self, author: str, target: str, amount: int) -> None:
+        super().__init__(author, target)
+
+        self.amount: int = amount
+        self.currency: str = 'HC'
+        self.reason: str = None

nsarchive/cls/bank.py

@@ -0,0 +1,7 @@
+class BankAccount:
+    def __init__(self, id: str) -> None:
+        self.id: str = id
+        self.owner: str = '0'
+        self.amount: int = 0
+        self.locked: bool = False
+        self.bank: str = "HexaBank"

nsarchive/cls/entities.py

@@ -1,23 +1,18 @@
+import io
 import time
 
 from .exceptions import *
 
+from ..utils import assets
+
 class Entity:
-    def __init__(self, id: str):
-        self.id: str = id # ID hexadécimal de l'entité
-        self.name: str = 'Entité Inconnue'
+    def __init__(self, id: str) -> None:
+        self.id: str = 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: int = 'Normal'
-        self.xp: int = 0
-
-    def get_level(self) -> None:
-        i = 0
-        while self.xp > int(round(25 * (i * 2.5) ** 2, -2)):
-            i += 1
-
-        return i
+        self.legalPosition: str = 'Membre'
     
-    def rename(self, new_name: str) -> None:
+    def set_name(self, new_name: str) -> None:
         if len(new_name) > 32:
             raise NameTooLongError(f"Name length mustn't exceed 32 characters.")
         
@@ -25,36 +20,80 @@ class Entity:
     
     def set_position(self, position: str) -> None:
         self.legalPosition = position
-    
-    def add_xp(self, amount: int) -> None:
-        boost = 0 if 0 in self.boosts.values() else max(list(self.boosts.values()) + [ 1 ])
 
-        self.xp += amount * boost
-    
 class User(Entity):
-    def __init__(self, id: str):
+    def __init__(self, id: str) -> None:
         super().__init__(id)
 
+        self.xp: int = 0
         self.boosts: dict[str, int] = {}
+
+    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() else max(list(self.boosts.values()) + [ 1 ])
+
+        self.xp += amount * boost
+
     def edit_boost(self, name: str, multiplier: int = -1) -> None:
         if multiplier >= 0:
             self.boosts[name] = multiplier
         else:
             del self.boosts[name]
 
+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
+    
+    def edit(self, **permissions: bool) -> None:
+        for perm in permissions.values():
+            self.__setattr__(*perm)
+
+class GroupMember(User):
+    def __init__(self, id: str) -> None:
+        super().__init__(id)
+
+        self.permissions: MemberPermissions = MemberPermissions()
+
+class FunctionalUser:
+    def __init__(self, id: str) -> None:
+        self.id: str = 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 Organization(Entity):
-    def __init__(self, id: str):
+    def __init__(self, id: str) -> None:
         super().__init__(id)
 
         self.owner: Entity
         self.certifications: dict = {}
-        self.members: list = []
-    
+        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())
     
-    def add_member(self, member: User) -> None:
+    def add_member(self, member: GroupMember) -> None:
         self.members.append(member)
     
     def remove_member(self, member: User) -> None:
@@ -62,4 +101,12 @@ class Organization(Entity):
             self.members.remove(member)
     
     def set_owner(self, member: User) -> None:
-        self.owner = member
+        self.owner = member
+
+    def get_member_id(self) -> list[str]:
+        return [ member.id for member in self.members ]
+
+class Elector(User):
+    def __init__(self, id: str) -> None:
+        super().__init__(id)
+        self.votes: list[str] = []

nsarchive/cls/exceptions.py

@@ -8,6 +8,9 @@ class EntityTypeError(Exception):
     def __init__(self, *args: object) -> None:
         super().__init__(*args)
 
+class AvatarTooLongError(Exception):
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
 
 # Exceptions pour le vote
 

nsarchive/cls/republic.py

@@ -0,0 +1,59 @@
+from .entities import *
+
+# Votes
+
+class Vote:
+    def __init__(self, id: str, title: str, choices: tuple[str]) -> None:
+        self.id: str = id
+        self.title: str = title
+        self.choices = { choice : 0 for choice in choices }
+        self.author: str = '0'
+        self.startDate: int = 0
+        self.endDate: int = 0
+
+class ClosedVote(Vote):
+    def __init__(self, id: str, title: str) -> None:
+        super().__init__(id, title, ('yes', 'no', 'blank'))
+
+
+# Institutions (defs)
+
+class Administration:
+    def __init__(self) -> None:
+        self.president: FunctionalUser
+        self.members: list[FunctionalUser]
+
+class Government:
+    def __init__(self, president: FunctionalUser) -> None:
+        self.president: FunctionalUser = president
+        self.prime_minister: FunctionalUser
+
+        self.inner_minister: FunctionalUser
+        self.economy_minister: FunctionalUser
+        self.justice_minister: FunctionalUser
+        self.press_minister: FunctionalUser
+        self.outer_minister: FunctionalUser
+
+class Assembly:
+    def __init__(self) -> None:
+        self.president: FunctionalUser
+        self.members: list[FunctionalUser]
+
+class Court:
+    def __init__(self) -> None:
+        self.president: FunctionalUser
+        # 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[FunctionalUser]
+
+class PoliceForces:
+    def __init__(self) -> None:
+        self.president: FunctionalUser
+        self.members: list[FunctionalUser]
+
+class Institutions:
+    def __init__(self) -> None:
+        self.administration: Administration
+        self.government: Government
+        self.court: Court
+        self.assembly: Assembly
+        self.police: PoliceForces

nsarchive/utils/assets.py

@@ -0,0 +1,15 @@
+import io
+import os
+from PIL import Image
+
+def open(path: str) -> Image:
+    curr_dir = os.path.dirname(os.path.abspath(os.path.join(__file__)))
+    parent_dir = os.path.dirname(curr_dir)
+    asset_path = os.path.join(parent_dir, 'assets', path)
+
+    image = Image.open(asset_path)
+    val = io.BytesIO()
+
+    image.save(val, format = 'PNG')
+
+    return val.getvalue()

nsarchive-0.1b0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.1
+Name: nsarchive
+Version: 0.1b0
+Summary: 
+License: GPL-3.0
+Author: happex
+Author-email: 110610727+okayhappex@users.noreply.github.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+# nsarchive
+
+`nsarchive` est un module Python pour la gestion des entités (utilisateurs et organisations) à l'aide de la base de données Deta. Ce module permet de créer, récupérer, sauvegarder et gérer des entités et leurs attributs spécifiques.
+
+## Pré-requis
+
+Listes des choses à avoir afin de pouvoir utiliser le module correctement:
+- [Python 3.10](https://www.python.org/downloads/) ou supérieur
+- Un token [Deta](https://deta.space), donné par un administrateur ou pour votre collection personnelle
+- Un bon capuccino, pour commencer la programmation en bons termes
+
+> **Note:** Il vous faudra un token différent pour accéder aux différentes parties de la base de données. Vos tokens n'expireront pas à moins que l'ordre en aura été donné
+
+## Installation
+
+Vous pouvez installer ce module via pip :
+
+```sh
+pip install nsarchive
+```
+
+## Utilisation
+
+### Importation et Initialisation
+
+Pour utiliser `nsarchive`, commencez par importer le module et initialiser une instance d'`EntityInstance` avec votre token Deta.
+
+```python
+from nsarchive import EntityInstance
+
+# Remplacez 'your_deta_token' par votre véritable token Deta
+entity_instance = EntityInstance(token = 'your_deta_token')
+```
+
+### Récupérer une Entité
+
+Vous pouvez récupérer une entité (Utilisateur ou Organisation) à l'aide de son ID.
+
+```python
+entity = entity_instance.get_entity(id = 'entity_id')
+print(entity.name)
+```
+
+**ATTENTION: Les entités sont identifiées sous une forme hexadécimale. Pour les avoir, vous devez convertir leur ID Discord en hexadécimale puis enlever le préfixe `0x`.**
+
+Pour les organisations, l'ID Discord correspondra à la formule suivante: `ID fondateur // 100000`.
+
+N'oubliez pas de toujours utiliser un `str` dans les ID pour interagir avec la base de données.
+
+### Sauvegarder une Entité
+
+Après avoir modifié une entité, vous pouvez la sauvegarder dans la base de données.
+
+```python
+entity.rename("Nouveau Nom")
+entity_instance.save_entity(entity)
+```
+
+### Rechercher des Entités
+
+Vous pouvez rechercher des entités avec des critères spécifiques.
+
+```python
+entities = entity_instance.fetch_entity(query = {'name': 'Alice'})
+for entity in entities:
+    print(entity['name'])
+```
+
+### Gérer les Organisations
+
+Les organisations peuvent avoir des membres et des certifications. Voici comment ajouter un membre ou une certification.
+
+```python
+organization = entity_instance.get_entity(id = 'org_id')
+user = entity_instance.get_entity(id = 'user_id')
+
+# Ajouter un membre
+organization.add_member(user)
+entity_instance.save_entity(organization)
+
+# Ajouter une certification
+organization.add_certification('Certification Example')
+entity_instance.save_entity(organization)
+```
+
+Les certifications pourront être utilisées pour vérifier l'officialité d'une organisation, mais également pour déterminer si l'on peut accorder (ou non) des permissions à ses membres.
+
+### Exemples de Classes
+
+#### `Entity`
+
+Classe parente des classes `User` et `Organization`, elle est utilisée lorsque le module ne peut pas déterminer l'appartenance d'une identité à l'une de ces deux classes ou à l'autre.
+
+```python
+from nsarchive.cls.entities import Entity
+
+entity = Entity(id='entity_id')
+entity.rename('New Name')
+entity.add_xp(100)
+print(entity.get_level())
+```
+
+#### `User`
+
+```python
+from nsarchive.cls.entities import User
+
+user = User(id = 'user_id')
+user.edit_boost(name = 'admin', multiplier = 5) # Négliger le paramètre <multiplier> ou le fixer à un nombre négatif reviendrait à supprimer le boost.
+print(user.boosts)
+```
+
+> **Note:** Lorsqu'on ajoute de l'expérience à un utilisateur via la méthode `add_xp`, le nombre de points ajoutés est automatiquement multiplié par le bonus le plus important dont l'utilisateur bénéficie.
+
+#### `Organization`
+
+```python
+from nsarchive.cls.entities import Organization
+
+organization = Organization(id = 'org_id')
+organization.set_owner(user)
+organization.add_member(user)
+print(organization.members)
+```
+
+> **Note:** Les attributs `owner` et `members` sont indépendants. L'owner peut être n'importe quelle personne faisant ou non partie des `members`.
+
+## Gestion des Exceptions
+
+`nsarchive` fournit des exceptions spécifiques pour gérer les erreurs courantes.
+
+#### `NameTooLongError`
+
+Lancé lorsque le nom d'une entité dépasse la longueur maximale autorisée (32 caractères).
+
+```python
+from nsarchive.cls.exceptions import NameTooLongError
+
+try:
+    entity.rename('Ce nom est long, voire même très long, je dirais même extrêmement long')
+except NameTooLongError as e:
+    print(e)
+```
+
+#### `EntityTypeError`
+
+Lancé lorsque le type d'entité est incorrect. Vous ne devriez normalement pas la rencontrer en utilisant le module, mais elle pourrait vous être utile.
+
+```python
+from nsarchive.cls.exceptions import EntityTypeError
+
+try:
+    # Code qui peut lancer une EntityTypeError
+except EntityTypeError as e:
+    print(e)
+```
+
+## License
+
+Ce projet est sous licence GNU GPL-3.0 - Voir le fichier [LICENSE](LICENSE) pour plus de détails.

nsarchive-0.1b0.dist-info/RECORD

@@ -0,0 +1,12 @@
+nsarchive/__init__.py,sha256=Y-I47MuPc8FIHIhvt8RZ-t5TXAi7APD0XlfEjqevfjk,15273
+nsarchive/assets/default_avatar.png,sha256=n-4vG_WPke8LvbY3ZU6oA-H-OtRoIu7woKnRq9DCIlI,51764
+nsarchive/cls/archives.py,sha256=5C66pXuXAANRXNDqNTvIepRtUrXIWOL7ymmYiBHsHAY,1720
+nsarchive/cls/bank.py,sha256=OactEpRn8PGv7BwnBUbMpzgHqrvv4yx526AMzh9uBO8,220
+nsarchive/cls/entities.py,sha256=u5u46HzHJp2H_DngLALLgedHaLXlJpjhmxU_Ggozp3Q,3474
+nsarchive/cls/exceptions.py,sha256=UZ7G7AFUN5OkKAGpNl1OT7jauF1jC7WW8wWXVFt5sMs,539
+nsarchive/cls/republic.py,sha256=aY79B5PZF5IErwzEjn9ito6T8gXA4trm6LmIeYu6XLM,1821
+nsarchive/utils/assets.py,sha256=hd0STSpa0yT-OJlUyI_wCYXJqcBiUMQds2pZTXNNg9c,382
+nsarchive-0.1b0.dist-info/LICENSE,sha256=aFLFZg6LEJFpTlNQ8su3__jw4GfV-xWBmC1cePkKZVw,35802
+nsarchive-0.1b0.dist-info/METADATA,sha256=rvpiq-iES71BGQ2r4pUmSPeItUkt0KW6u-XqZExWNXk,5559
+nsarchive-0.1b0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+nsarchive-0.1b0.dist-info/RECORD,,

nsarchive/cls/votes.py

@@ -1,7 +0,0 @@
-import time
-
-class Vote:
-    def __init__(self, id: int, title: str, choices: list[str]) -> None:
-        self.id: int = id
-        self.title: str = title
-        self.choices = { choice : 0 for choice in choices }

nsarchive-0.1a0.dist-info/METADATA

@@ -1,17 +0,0 @@
-Metadata-Version: 2.1
-Name: nsarchive
-Version: 0.1a0
-Summary: 
-License: GPL-3.0
-Author: happex
-Author-email: 110610727+okayhappex@users.noreply.github.com
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Description-Content-Type: text/markdown
-
-# 1ns-archive
-

nsarchive-0.1a0.dist-info/RECORD

@@ -1,8 +0,0 @@
-nsarchive/__init__.py,sha256=cWlY3WvOeAmzwU0TC6VH0V2NfZeL4dbi_7ocneQ5els,2767
-nsarchive/cls/entities.py,sha256=IrQSciTyb1fS-AumcGxyD35ONfvNa49CwfTQNDrFEkA,1895
-nsarchive/cls/exceptions.py,sha256=TrH9PvHhVZi7wap9ZfBLGRWJY3OBCYgWAMnco5uadYY,420
-nsarchive/cls/votes.py,sha256=p5QnvQQTaKkZDjfZa2qDgGrpCmu4vQV8-9drPayZ0oE,221
-nsarchive-0.1a0.dist-info/LICENSE,sha256=aFLFZg6LEJFpTlNQ8su3__jw4GfV-xWBmC1cePkKZVw,35802
-nsarchive-0.1a0.dist-info/METADATA,sha256=Kn6vtRhpgpk091l-IlmMpfUGVf8bbnfig0eA63c93cw,518
-nsarchive-0.1a0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-nsarchive-0.1a0.dist-info/RECORD,,