From 198f8c273d8f6a2c2c9249abbe0f31577a75eebb Mon Sep 17 00:00:00 2001 From: danielSanchezQ <3danimanimal@gmail.com> Date: Thu, 17 Jul 2025 07:34:06 +0000 Subject: [PATCH] DeclarationId to ProviderId --- da/assignations/refill.py | 28 ++++++++++++++-------------- da/assignations/test_refill.py | 10 +++++----- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/da/assignations/refill.py b/da/assignations/refill.py index 4e79d91..9f6ca54 100644 --- a/da/assignations/refill.py +++ b/da/assignations/refill.py @@ -7,23 +7,23 @@ from collections import Counter from heapq import heappush, heappop, heapify -DeclarationId: TypeAlias = bytes -Assignations: TypeAlias = List[Set[DeclarationId]] +ProviderId: TypeAlias = bytes +Assignations: TypeAlias = List[Set[ProviderId]] BlakeRng: TypeAlias = Any @dataclass(order=True) class Participant: # Participant's wrapper class - # Used for keeping ordering in the heap by the participation first and the declaration id second + # Used for keeping ordering in the heap by the participation first and the provider id second participation: int # prioritize participation count first - declaration_id: DeclarationId # sort by id on default + provider_id: ProviderId # sort by id on default @dataclass class Subnetwork: # Subnetwork wrapper that keeps the subnetwork id [0..2048) and the set of participants in that subnetwork - participants: Set[DeclarationId] + participants: Set[ProviderId] subnetwork_id: int def __lt__(self, other): @@ -47,7 +47,7 @@ def all_nodes_assigned(participants: Sequence[Participant], average_participatio def heappop_next_for_subnetwork(subnetwork: Subnetwork, participants: List[Participant]) -> Participant: poped = [] participant = heappop(participants) - while participant.declaration_id in subnetwork.participants: + while participant.provider_id in subnetwork.participants: poped.append(participant) participant = heappop(participants) for poped in poped: @@ -79,11 +79,11 @@ def fill_subnetworks( # take the fewest participants subnetwork subnetwork = heappop(subnetworks) - # take the declaration with the lowest participation that is not included in the subnetwork + # take the provider with the lowest participation that is not included in the subnetwork participant = heappop_next_for_subnetwork(subnetwork, available_nodes) # fill into subnetwork - subnetwork.participants.add(participant.declaration_id) + subnetwork.participants.add(participant.provider_id) participant.participation += 1 # push to heaps heappush(available_nodes, participant) @@ -112,11 +112,11 @@ def balance_subnetworks_grow( ): for participant in filter(lambda x: x.participation > average_participation, sorted(participants)): for subnework in sample( - sorted(filter(lambda subnetwork: participant.declaration_id in subnetwork.participants, subnetworks)), + sorted(filter(lambda subnetwork: participant.provider_id in subnetwork.participants, subnetworks)), random, k=participant.participation - average_participation ): - subnework.participants.remove(participant.declaration_id) + subnework.participants.remove(participant.provider_id) participant.participation -= 1 @@ -129,7 +129,7 @@ def rand(seed: bytes): def calculate_subnetwork_assignations( - new_nodes_list: Sequence[DeclarationId], + new_nodes_list: Sequence[ProviderId], previous_subnets: Assignations, replication_factor: int, random_seed: bytes, @@ -146,7 +146,7 @@ def calculate_subnetwork_assignations( # 1) For each (sorted) participant, remove the participant from random subnetworks (coming from sorted list) # until the participation of is equal to the average participation. # 4. Create a heap with the set of active nodes ordered by, primary the number of subnetworks each participant is at - # and secondary by the DeclarationId of the participant (ascending order). + # and secondary by the ProviderId of the participant (ascending order). # 5. Create a heap with the subnetworks ordered by the number of participants in each subnetwork # 6. Until all subnetworks are filled up to a replication factor and all nodes are assigned: # 1) pop the subnetwork with the fewest participants @@ -169,11 +169,11 @@ def calculate_subnetwork_assignations( active_assignations = [subnet - unavailable_nodes for subnet in previous_subnets] # count participation per assigned node - assigned_count: Counter[DeclarationId] = Counter(chain.from_iterable(active_assignations)) + assigned_count: Counter[ProviderId] = Counter(chain.from_iterable(active_assignations)) # available nodes heap available_nodes = [ - Participant(participation=assigned_count.get(_id, 0), declaration_id=_id) for _id in new_nodes + Participant(participation=assigned_count.get(_id, 0), provider_id=_id) for _id in new_nodes ] # subnetworks heap diff --git a/da/assignations/test_refill.py b/da/assignations/test_refill.py index c62d240..cc0af5c 100644 --- a/da/assignations/test_refill.py +++ b/da/assignations/test_refill.py @@ -2,7 +2,7 @@ import random from itertools import chain from typing import List, Counter from unittest import TestCase -from da.assignations.refill import calculate_subnetwork_assignations, Assignations, DeclarationId +from da.assignations.refill import calculate_subnetwork_assignations, Assignations, ProviderId class TestRefill(TestCase): @@ -71,21 +71,21 @@ class TestRefill(TestCase): @classmethod - def mutate_nodes(cls, nodes: List[DeclarationId], count: int): + def mutate_nodes(cls, nodes: List[ProviderId], count: int): assert count < len(nodes) for i in random.choices(list(range(len(nodes))), k=count): nodes[i] = random.randbytes(32) @classmethod - def expand_nodes(cls, nodes: List[DeclarationId], count: int) -> List[DeclarationId]: + def expand_nodes(cls, nodes: List[ProviderId], count: int) -> List[ProviderId]: return [*nodes, *(random.randbytes(32) for _ in range(count))] @classmethod - def shrink_nodes(cls, nodes: List[DeclarationId], count: int) -> List[DeclarationId]: + def shrink_nodes(cls, nodes: List[ProviderId], count: int) -> List[ProviderId]: return list(random.sample(nodes, k=count)) - def assert_assignations(self, assignations: Assignations, nodes: List[DeclarationId], replication_factor: int): + def assert_assignations(self, assignations: Assignations, nodes: List[ProviderId], replication_factor: int): self.assertEqual( len(set(chain.from_iterable(assignations))), len(nodes),