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

nsarchive/__init__.py

@@ -4,7 +4,7 @@ import deta
 
 from .cls.entities import *
 from .cls.archives import *
-from .cls.votes import *
+from .cls.republic import *
 from .cls.bank import *
 
 from .cls.exceptions import *
@@ -15,6 +15,7 @@ class EntityInstance:
         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:
         id = id.upper()
@@ -25,26 +26,27 @@ class EntityInstance:
 
         if _data['_type'] == 'user':
             entity = User(id)
+
+            entity.xp = _data['xp']
+            entity.boosts = _data['boosts']
         elif _data['_type'] == 'organization':
             entity = Organization(id)
-        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'].upper())
             entity.members = [
                 self.get_entity(_id) for _id in _data['members']
             ]
 
+            entity.avatar = self.avatars.get(id).read()
+
             entity.certifications = _data['certifications']
-        elif type(entity) == User:
-            entity.boosts = _data['boosts']
-        
+        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']
+
         return entity
 
     def save_entity(self, entity: Entity) -> None:
@@ -53,15 +55,17 @@ class EntityInstance:
             '_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.upper() if entity.owner else "0"
             _data['members'] = [ member.id.upper() for member in entity.members ] if entity.members else []
-            _data['certifications']  = entity.certifications
+            _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.upper(), expire_in = 3 * 31536000) # Données supprimées tous les trois ans
@@ -69,6 +73,9 @@ class EntityInstance:
     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)
@@ -88,8 +95,11 @@ class EntityInstance:
         }
 
         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:
@@ -98,17 +108,17 @@ class EntityInstance:
                     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({'_type': 'organization'}, {'members': id})
+        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) == ModAction:
+        if type(archive) == Sanction:
             _data['type'] = "sanction"
         elif type(archive) == AdminAction:
             _data['type'] = "adminaction"
@@ -119,37 +129,44 @@ class EntityInstance:
 
         self.archives.put(key = archive.id, data = _data)
 
-    def _get_archive(self, id: str) -> Action | ModAction | AdminAction:
+    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 = ModAction(id, _data['author'], _data['target'])
+            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
-            archive = AdminAction(id, _data['author'], _data['target'])
+        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(id, _data['author'], _data['target'])
+            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.functions = self.db.base('functions') # Liste des fonctionnaires
+        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()
@@ -184,6 +201,94 @@ class RepublicInstance:
 
         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()
 
@@ -207,22 +312,29 @@ class RepublicInstance:
             return None
         
         if _data['type'] == "election":
-            archive = Election(id, _data['author'], _data['target'], _data['position'])
+            archive = Election(_data['author'], _data['target'], _data['position'])
 
             archive.positive_votes = _data['positive_votes']
             archive.total_votes = _data['total_votes']
-        elif _data['type'] == "adminaction": # Renommage, promotion, démotion
-            archive = AdminAction(id, _data['author'], _data['target'])
+        elif _data['type'] == "promotion":
+            archive = Promotion(_data['author'], _data['target'], _data['position'])
+        elif _data['type'] == "demotion":
+            archive = Demotion(_data['author'], _data['target'])
 
-            archive.details = _data['details']
-            archive.new_state = _data['new_state']
+            archive.reason = _data['reason']
         else:
-            archive = Action(id, _data['author'], _data['target'])
+            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:
@@ -255,6 +367,11 @@ class BankInstance:
         }
 
         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()
@@ -275,14 +392,20 @@ class BankInstance:
             return None
         
         if _data['type'] == "transaction":
-            archive = Transaction(id, _data['author'], _data['target'], _data['amount'])
+            archive = Transaction(_data['author'], _data['target'], _data['amount'])
 
             archive.reason = _data['reason']
             archive.currency = _data['currency']
         else:
-            archive = Action(id, _data['author'], _data['target'])
+            archive = Action(_data['author'], _data['target'])
         
+        archive.id = id
         archive.action = _data['action']
         archive.date = _data['date']
 
-        return archive
+        return archive
+    
+    def _fetch_archives(self, **query) -> list[ Action | Transaction ]:
+        _res = self.archives.fetch(query).items
+        
+        return [ self._get_archive(archive['key']) for archive in _res ]

nsarchive/cls/archives.py

@@ -1,23 +1,28 @@
+import time
+
 class Action:
-    def __init__(self, id: str, author: str = '11625D9061021010', target: str = '0') -> None:
-        self.id: str = id
-        self.date: int = 0
+    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 ModAction(Action):
-    def __init__(self, id: str, author: str, target: str) -> None:
-        super().__init__(id, author, target)
+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, id: str, author: str, target: str) -> None:
-        super().__init__(id, author, target)
+    def __init__(self, author: str, target: str) -> None:
+        super().__init__(author, target)
+
         self.details: str = ""
         self.new_state: str | int | bool = None
 
@@ -25,28 +30,31 @@ class AdminAction(Action):
 # Community
 
 class Election(Action):
-    def __init__(self, id: str, author: str, target: str, position: str) -> None:
-        super().__init__(id, author, target)
+    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, id: str, author: str, target: str, position: str) -> None:
-        super().__init__(id, author, target)
+    def __init__(self, author: str, target: str, position: str) -> None:
+        super().__init__(author, target)
+
         self.position: str = position
 
 class Demotion(Action):
-    def __init__(self, id: str, author: str, target: str) -> None:
-        super().__init__(id, author, target)
+    def __init__(self, author: str, target: str) -> None:
+        super().__init__(author, target)
+
         self.reason: str = None
 
 # Bank
 
 class Transaction(Action):
-    def __init__(self, id: str, author: str, target: str, amount: int) -> None:
-        super().__init__(id, author, target)
+    def __init__(self, author: str, target: str, amount: int) -> None:
+        super().__init__(author, target)
 
         self.amount: int = amount
-        self.currency: str = 'XC'
-        self.reason: str = None
+        self.currency: str = 'HC'
+        self.reason: str = None

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é
+    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:
@@ -64,27 +103,10 @@ 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 ]
+
 class Elector(User):
     def __init__(self, id: str) -> None:
-        self.id: str = id
-        self.votes: list[str] = []
-
-class FunctionalUser(User):
-    def __init__(self, id: str):
         super().__init__(id)
-
-        self.permissions: dict = {
-            'approve_project': False,
-            'create_org': False,
-            'destroy_gov': False,
-            'destroy_org': False,
-            'propose_projects': False
-        }
-
-        self.mandates: int = 0
-        self.contribs: dict = {
-            'projects': 0,
-            'approved_projects': 0, 
-            'admin_actions': 0, 
-            'law_votes': 0
-        }
+        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.0.9a0.dist-info → nsarchive-0.1b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nsarchive
-Version: 0.0.9a0
+Version: 0.1b0
 Summary: 
 License: GPL-3.0
 Author: happex
@@ -76,7 +76,7 @@ entity_instance.save_entity(entity)
 Vous pouvez rechercher des entités avec des critères spécifiques.
 
 ```python
-entities = entity_instance.fetch(query = {'name': 'Alice'})
+entities = entity_instance.fetch_entity(query = {'name': 'Alice'})
 for entity in entities:
     print(entity['name'])
 ```

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,16 +0,0 @@
-import time
-
-from .entities import FunctionalUser
-
-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'))

nsarchive-0.0.9a0.dist-info/RECORD

@@ -1,10 +0,0 @@
-nsarchive/__init__.py,sha256=uno-FOUWDtdaMVeufH4C7FuRq8l_dp46EgoJokI-Sm0,9516
-nsarchive/cls/archives.py,sha256=FNE8U3IVgjYCUZkBoDqeyQJSHKmRjP2UAzBfmg8nK0M,1735
-nsarchive/cls/bank.py,sha256=OactEpRn8PGv7BwnBUbMpzgHqrvv4yx526AMzh9uBO8,220
-nsarchive/cls/entities.py,sha256=eY5Fjxt5iixvJCxDnCNbD_lIMq9ojbCLDduPqe52oWM,2556
-nsarchive/cls/exceptions.py,sha256=TrH9PvHhVZi7wap9ZfBLGRWJY3OBCYgWAMnco5uadYY,420
-nsarchive/cls/votes.py,sha256=q_Y_KcFoqoXWzh_FSWz-1tJH7fGdGJDCORYUOWCtdS8,502
-nsarchive-0.0.9a0.dist-info/LICENSE,sha256=aFLFZg6LEJFpTlNQ8su3__jw4GfV-xWBmC1cePkKZVw,35802
-nsarchive-0.0.9a0.dist-info/METADATA,sha256=7piU3_JrfSVGMC12pC02kwbio2JPRqLxyKlRk47bvnE,5554
-nsarchive-0.0.9a0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-nsarchive-0.0.9a0.dist-info/RECORD,,