nsarchive 1.4.0__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

nsarchive/instances/_entities.py

@@ -0,0 +1,311 @@
+from supabase import create_client
+
+from ..cls.base import *
+from ..cls.entities import *
+from ..cls.archives import *
+
+from ..cls.exceptions import *
+
+class EntityInstance(Instance):
+    """
+    Instance 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, id: str, token: str) -> None:
+        super().__init__(create_client(f"https://{id}.supabase.co", token))
+
+    """
+    ---- ENTITÉS ----
+    """
+
+    def get_entity(self, id: str | NSID) -> User | Organization | Entity:
+        """
+        Fonction permettant de récupérer le profil public d'une entité.\n
+
+        ## Paramètres
+        id: `NSID`\n
+            ID héxadécimal de l'entité à récupérer
+
+        ## 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)
+
+        _data = self._get_by_ID('individuals', id)
+
+        if _data is None: # Aucune entité individuelle sous cet ID
+            _data = self._get_by_ID('organizations', id) # On cherche du côté des groupes
+        else:
+            _data['_type'] = 'user'
+
+        if _data is None: # ID inexistant chez les entités
+            return None
+        elif '_type' not in _data.keys(): # S'il existe chez les organisations, clé '_type' pas encore initialisée
+            _data['_type'] = 'organization'
+
+        if _data['_type'] == 'user':
+            entity = User(id)
+
+            entity.xp = _data['xp']
+            entity.boosts = _data['boosts']
+
+            entity.votes = [ NSID(vote) for vote in _data['votes'] ]
+        elif _data['_type'] == 'organization':
+            entity = Organization(id)
+
+            entity.owner = self.get_entity(NSID(_data['owner_id']))
+
+            for _member in _data['members']:
+                member = GroupMember(_member['id'])
+                member.permission_level = _member['level']
+
+                _member_profile = self.get_entity(member.id)
+
+                member.set_name(_member_profile.name)
+                member.legalPosition = _member_profile.legalPosition
+                member.registerDate = _member_profile.registerDate
+
+                member.xp = _member_profile.xp
+                member.boosts = _member_profile.boosts
+
+                member.permissions = _member_profile.permissions
+                member.votes = _member_profile.votes
+
+                entity.append(member)
+
+            entity.certifications = _data['certifications']
+            entity.shares = _data['shares']
+        else:
+            entity = Entity(id)
+
+        entity.name = _data['name']
+        entity.legalPosition = _data['position'] # Métier si c'est un utilisateur, domaine professionnel si c'est un collectif
+        entity.registerDate = _data['register_date']
+
+        for  key, value in _data.get('additional', {}).items():
+            if isinstance(value, str) and value.startswith('\n'):
+                entity.add_link(key, int(value[1:]))
+            else:
+                entity.add_link(key, value)
+
+        return entity
+
+    def save_entity(self, entity: Entity) -> None:
+        """
+        Fonction permettant de créer ou modifier une entité.
+
+        ## Paramètres
+        entity: `.Entity` ( `.User | .Organization` )
+            L'entité à sauvegarder
+        """
+
+        entity.id = NSID(entity.id)
+
+        _data = {
+            'id': entity.id,
+            'name': entity.name,
+            'position': entity.legalPosition,
+            'register_date': entity.registerDate,
+            'additional': {},
+        }
+
+        for key, value in entity.additional.items():
+            if isinstance(value, int) and len(str(int)) >= 15:
+                _data['additional'][key] = '\n' + str(value)
+            elif type(value) in (str, int):
+                _data['additional'][key] = value
+
+        if type(entity) == Organization:
+            _data['owner_id'] = NSID(entity.owner.id) if entity.owner else NSID("0")
+            _data['members'] = []
+            _data['certifications'] = entity.certifications
+
+            for member in entity.members:
+                _member = {
+                    'id': NSID(member.id),
+                    'position': member.permission_level
+                }
+
+                _data['members'] += [_member]                
+        elif type(entity) == User:
+            _data['xp'] = entity.xp
+            _data['boosts'] = entity.boosts
+            _data['votes'] = [ NSID(vote) for vote in entity.votes]
+
+        self._put_in_db('individuals' if isinstance(entity, User) else 'organizations', _data)
+
+    def delete_entity(self, entity: Entity) -> None:
+        """
+        Fonction permettant de supprimer le profil d'une entité
+
+        ## Paramètres
+        entity: `.Entity` ( `.User | .Organization` )
+            L'entité à supprimer
+        """
+
+        self._delete_by_ID('individuals' if isinstance(entity, User) else 'organizations', NSID(entity.id))
+
+    def fetch_entities(self, query: dict = None) -> list[ Entity | User | Organization ]:
+        """
+        Récupère une liste d'entités en fonction d'une requête.
+
+        ## Paramètres
+        query: `dict`
+            La requête pour filtrer les entités.
+
+        ## Renvoie
+        - `list[Entity | User | Organization]`
+        """
+
+        _res = self.fetch('entities', **query)
+
+        return [ self.get_entity(NSID(entity['key'])) for entity in _res if entity is not None ]
+
+    def get_entity_groups(self, id: str | NSID) -> list[Organization]:
+        """
+        Récupère les groupes auxquels appartient une entité.
+
+        ## Paramètres
+        id: `str | NSID`
+            ID de l'entité.
+
+        ## Renvoie
+        - `list[Organization]`
+        """
+
+        id = NSID(id)
+        groups = self.fetch_entities({'_type': 'organization'})
+        groups.extend(self.fetch_entities({'_type': 'organization', 'owner_id': id}))
+
+        for group in groups:
+            if group is None:
+                groups.remove(group)
+                continue
+
+            if group.owner.id == id:
+                continue
+
+            for member in group.members:
+                if member.id == id:
+                    break
+            else:
+                groups.remove(group)
+
+        return [ group for group in groups if group is not None ]
+
+    def get_position(self, id: str) -> Position:
+        """
+        Récupère une position légale (métier, domaine professionnel).
+
+        ## Paramètres
+        id: `str`
+            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.name = _data['name']
+        position.permissions.edit(dict(zip(_data['permissions'], True)))
+
+        return position
+
+    """
+    ---- ARCHIVES --
+    """
+
+    def _add_archive(self, archive: Action) -> None:
+        """
+        Ajoute une archive d'une action (modification au sein d'un groupe ou sanction) dans la base de données.
+        """
+
+        archive.id = NSID(archive.id)
+        archive.author = NSID(archive.author)
+        archive.target = NSID(archive.target)
+
+        _data = archive.__dict__.copy()
+
+        if type(archive) == Sanction:
+            _data['type'] = "sanction"
+        elif type(archive) == AdminAction:
+            _data['type'] = "adminaction"
+        elif type(archive) == Report:
+            _data['type'] = "report"
+        else:
+            _data['type'] = "unknown"
+
+        self._put_in_db('archives', _data)
+
+    def _get_archive(self, id: str | NSID) -> Action | Sanction | AdminAction:
+        """
+        Récupère une archive spécifique.
+
+        ## Paramètres
+        id: `str | NSID`
+            ID de l'archive.
+
+        ## Renvoie
+        - `.Action | .Sanction | .AdminAction`
+        """
+
+        id = NSID(id)
+        _data = self._get_by_ID('archives', 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']
+        elif _data['type'] == "report": # Plainte
+            archive = Report(_data['author'], _data['target'])
+
+            archive.details = _data['details']
+        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 ]:
+        """
+        Récupère une liste d'archives correspondant à la requête.
+
+        ## Paramètres
+        query: `dict`
+            Requête pour filtrer les archives.
+
+        ## Renvoie
+        - `list[Action | Sanction | AdminAction]`
+        """
+
+        _res = self.fetch('archives', **query)
+
+        return [ self._get_archive(archive['key']) for archive in _res ]

nsarchive/instances/_republic.py

@@ -0,0 +1,282 @@
+import time
+
+from supabase import create_client
+
+from ..cls.base import *
+from ..cls.archives import *
+from ..cls.republic import *
+
+from ..cls.exceptions import *
+
+
+class RepublicInstance(Instance):
+    """
+    Gère les interactions avec les votes, les archives de la république, et les fonctionnaires.
+
+    ## Informations
+    - Résultats des votes: `.Vote | .ClosedVote`
+    - Différentes institutions: `.Institutions | .Administration | .Government | .Assembly | .Court | .PoliceForces`
+    - Occupants des différents rôles et historique de leurs actions: `.Official`
+    """
+
+    def __init__(self, id: str, token: str) -> None:
+        super().__init__(create_client(f"https://{id}.supabase.co", token))
+    
+    """
+    ---- VOTES & REFERENDUMS ----
+    """
+
+    def get_vote(self, id: str | NSID) -> Vote | ClosedVote | Lawsuit:
+        """
+        Récupère un vote spécifique.
+
+        ## Paramètres
+        id: `str | NSID`\n
+            ID du vote.
+
+        ## Renvoie
+        - `.Vote | .ClosedVote`
+        """
+
+        id = NSID(id)
+        _data = self._get_by_ID('votes', 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'])
+        elif _data['_type'] == 'lawsuit':
+            vote = Lawsuit(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) -> None:
+        """Sauvegarde un vote dans la base de données."""
+
+        vote.id = NSID(vote.id)
+
+        _data = {
+            '_type':'open' if type(vote) == Vote else\
+                    'closed' if type(vote) == ClosedVote else\
+                    'lawsuit' if type(vote) == Lawsuit else\
+                    'unknown',
+            'title': vote.title,
+            'author': NSID(vote.author),
+            'startDate': vote.startDate,
+            'endDate': vote.endDate,
+            'choices': vote.choices
+        }
+
+        self._put_in_db('votes', _data)
+
+    # Aucune possibilité de supprimer un vote
+
+    """
+    ---- INSTITUTION & MANDAT ----
+    """
+
+    def get_official(self, id: str | NSID, current_mandate: bool = True) -> Official:
+        """
+        Récupère les informations d'un fonctionnaire (mandats, contributions).
+
+        ## Paramètres
+        id: `str | NSID`\n
+            ID du fonctionnaire.
+        current_mandate: `bool`\n
+            Indique si l'on doit récupérer le mandat actuel ou les anciens mandats.
+
+        ## Renvoie
+        - `.Official`
+        """
+
+        id = NSID(id)
+
+        base = 'mandate' if current_mandate else 'archives'
+
+        _contributions = self.fetch(base, {'author': id, 'type': 'contrib'})
+        _mandates = self.fetch(base, {'target': id, 'type': 'election'}) +\
+                    self.fetch(base, {'target': id, 'type': 'promotion'})
+
+        user = Official(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) -> State:
+        """Récupère l'état actuel des institutions de la république."""
+
+        admin = Administration()
+        gov = Government(Official('0'))
+        assembly = Assembly()
+        court = Court()
+        police_forces = PoliceForces()
+
+        _get_position: list[dict] = lambda pos : self._select_from_db('functions', 'id', pos)['users']
+
+        admin.members = [ self.get_official(user['id']) for user in _get_position('ADMIN') ]
+        admin.president = self.get_official('F7DB60DD1C4300A') # happex (remplace Kheops pour l'instant)
+
+        gov.president = self.get_official([0])
+
+        minister = lambda code : self.get_official(_get_position(f'MIN_{code}')[0]['id'])
+        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(_get_position('PRE_AS')[0])
+        assembly.members = [ self.get_official(user['id']) for user in _get_position('REPR') ]
+
+        court.president = gov.justice_minister
+        court.members = [ self.get_official(user['id']) for user in _get_position('JUDGE') ]
+
+        police_forces.president = gov.inner_minister
+        police_forces.members = [ self.get_official(user['id']) for user in _get_position('POLICE') ]
+
+        instits = State()
+        instits.administration = admin
+        instits.government = gov
+        instits.court = court
+        instits.assembly = assembly
+        instits.police = police_forces
+
+        return instits
+
+    def update_institutions(self, institutions: State):
+        """
+        Fonction communément appelée après un vote législatif ou une nomination.\n
+        Celle-ci met à jour: Le gouvernement (président, ministres), les différents députés et leur président, les différents juges, les différents policiers.\n
+
+        ## Paramètres
+        institutions: `.Institutions`\n
+            Le nouvel état des institutions, à sauvegarder.
+        """
+
+        get_ids = lambda institution : [ member.id for member in institutions.__getattribute__(institution).members ]
+
+        self._put_in_db('functions', { 'users': get_ids('administration') })
+        self._put_in_db('functions', { 'users': get_ids('assembly') })
+        self._put_in_db('functions', { 'users': get_ids('court') })
+        self._put_in_db('functions', { 'users': get_ids('police') })
+
+        self._put_in_db('functions', { 'users': [ institutions.assembly.president.id ] })
+        self._put_in_db('functions', { 'users': [ institutions.government.president.id ] })
+
+        self._put_in_db('functions', { 'users': [ institutions.government.prime_minister.id ] })
+        self._put_in_db('functions', { 'users': [ institutions.government.inner_minister.id ] })
+        self._put_in_db('functions', { 'users': [ institutions.government.justice_minister.id ] })
+        self._put_in_db('functions', { 'users': [ institutions.government.economy_minister.id ] })
+        self._put_in_db('functions', { 'users': [ institutions.government.press_minister.id ] })
+        self._put_in_db('functions', { 'users': [ institutions.government.outer_minister.id ] })
+
+    def new_mandate(self, institutions: State, weeks: int = 4) -> None:
+        """
+        Fonction qui amène à supprimer toutes les archives du mandat précédent
+        """
+
+        for item in self.fetch('mandate'):
+            if item['date'] >= round(time.time()) - weeks * 604800: # On évite de supprimer les informations écrites lors de la période définie
+                self._delete_by_ID('mandate', item['id'])
+
+        self.update_institutions(institutions)
+
+    """
+    ---- ARCHIVES ----
+    """
+
+    def _add_archive(self, archive: Action) -> None:
+        """Ajoute une archive d'une action (élection, promotion, ou rétrogradation) dans la base de données."""
+
+        archive.id = NSID(archive.id)
+        _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"
+
+        self._put_in_db('archives', _data)
+        self._put_in_db('mandate', _data) # Ajouter les archives à celle du mandat actuel
+
+    def _get_archive(self, id: str | NSID) -> Action | Election | Promotion | Demotion:
+        """
+        Récupère une archive spécifique.
+
+        ## Paramètres
+        id: `str | NSID`\n
+            ID de l'archive.
+
+        ## Renvoie
+        - `.Action | .Election | .Promotion | .Demotion`
+        """
+
+        id = NSID(id)
+        _data = self._get_by_ID('archives', 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 ]:
+        """
+        Récupère une liste d'archives correspondant à la requête.
+
+        ## Paramètres
+        query: `dict`
+            Requête pour filtrer les archives.
+
+        ## Renvoie
+        - `list[Action | Election | Promotion | Demotion]`
+        """
+
+        _res = self.fetch('archives', **query)
+        
+        return [ self._get_archive(archive['key']) for archive in _res ]

nsarchive/utils/assets.py

@@ -2,7 +2,7 @@ import io
 import os
 from PIL import Image
 
-def open(path: str) -> Image:
+def open(path: str) -> bytes:
     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)

{nsarchive-1.4.0.dist-info → nsarchive-2.0.0a1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: nsarchive
-Version: 1.4.0
-Summary: 
+Version: 2.0.0a1
+Summary: API-wrapper pour récupérer des données liées à Nation
 License: GPL-3.0
 Author: happex
 Author-email: 110610727+okayhappex@users.noreply.github.com
@@ -11,8 +11,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: deta (>=1.2,<2.0)
 Requires-Dist: pillow (>=10.4,<11.0)
+Requires-Dist: supabase (>=2.9.1,<3.0.0)
 Description-Content-Type: text/markdown
 
 # nsarchive

nsarchive-2.0.0a1.dist-info/RECORD

@@ -0,0 +1,16 @@
+nsarchive/__init__.py,sha256=-yXGGJBOkoQo-6Vg6hJVIqr-C7sQyL_LaYcQ3yx9aFs,696
+nsarchive/assets/default_avatar.png,sha256=n-4vG_WPke8LvbY3ZU6oA-H-OtRoIu7woKnRq9DCIlI,51764
+nsarchive/cls/archives.py,sha256=i4R7NPYXX_1oi0oLAvL_4SqyjqPutXSXKysUetE6hME,2001
+nsarchive/cls/base.py,sha256=jJOsGgnURxR8YwJiIHgodPOmJ31LOtYDVbz33kIM5Yg,3512
+nsarchive/cls/economy.py,sha256=-eV8R5KMXSeXcKEu2G8OP1UgYgb0X6uks0aD2XhlbcU,1220
+nsarchive/cls/entities.py,sha256=i7tlx-fDpwGWsnGgpXrLcASLHYQjf1dXUCdr1mKc4Ik,6629
+nsarchive/cls/exceptions.py,sha256=QN6Qn7cxTkGoC4lO50hBAq4gZCgo7scQvCkb-xKl6Xs,692
+nsarchive/cls/republic.py,sha256=F6il2FrvCoutHxQlW3xM36GaFfIqdorg2jicMAlPdUo,2503
+nsarchive/instances/_economy.py,sha256=uZnuZadvZHZ9NwalIxJY0X25b_ubi7LU7A9DKwU_Wtc,6454
+nsarchive/instances/_entities.py,sha256=Xgdnctt1NiqxG4c0VozxKFj_X-hlm3EOc5T1TUk6OdQ,10332
+nsarchive/instances/_republic.py,sha256=yN7Pj7KdenPwIafv3_vfsd-fHXyN206qr8e-lEbBuQo,10168
+nsarchive/utils/assets.py,sha256=WGC03K1VZ5LwGzcVXbqphtGBZ_Vjso-1hmbIkpgL_X8,382
+nsarchive-2.0.0a1.dist-info/LICENSE,sha256=aFLFZg6LEJFpTlNQ8su3__jw4GfV-xWBmC1cePkKZVw,35802
+nsarchive-2.0.0a1.dist-info/METADATA,sha256=jDqBAFWTbkYtZQyuouXixJxO6HAv8bUX3K-dgeWFdOY,5697
+nsarchive-2.0.0a1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+nsarchive-2.0.0a1.dist-info/RECORD,,

nsarchive-1.4.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-nsarchive/__init__.py,sha256=85kvYTT-TSJgTX1AX-nVNI9GJANJS4S6UXCE3SpyUjE,27563
-nsarchive/assets/default_avatar.png,sha256=n-4vG_WPke8LvbY3ZU6oA-H-OtRoIu7woKnRq9DCIlI,51764
-nsarchive/cls/archives.py,sha256=i4R7NPYXX_1oi0oLAvL_4SqyjqPutXSXKysUetE6hME,2001
-nsarchive/cls/base.py,sha256=DGDm0uD96M00-qvdKsltU9kAfAOBr85Ov0b18gTnoIM,714
-nsarchive/cls/economy.py,sha256=JpNB06JHek4uUapdk89-SR3DEoSyxXPn8OqZJkOZH_E,1252
-nsarchive/cls/entities.py,sha256=7vhD6r6DuvTlyGyPmm1scpWFsqPGMUw7JQ9Ks8sHWpQ,6712
-nsarchive/cls/exceptions.py,sha256=QN6Qn7cxTkGoC4lO50hBAq4gZCgo7scQvCkb-xKl6Xs,692
-nsarchive/cls/republic.py,sha256=6eut6OsFoOm9TVhA41fM3NlMEA3Uhg9TCuXgl46vFko,1985
-nsarchive/utils/assets.py,sha256=hd0STSpa0yT-OJlUyI_wCYXJqcBiUMQds2pZTXNNg9c,382
-nsarchive-1.4.0.dist-info/LICENSE,sha256=aFLFZg6LEJFpTlNQ8su3__jw4GfV-xWBmC1cePkKZVw,35802
-nsarchive-1.4.0.dist-info/METADATA,sha256=MK4hOKyqSERSJtko967gMBPPdnzyqY-GFfx5pzaimts,5629
-nsarchive-1.4.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-nsarchive-1.4.0.dist-info/RECORD,,