class IDFactory(factory.Factory): class Meta: model = ID peer_id_bytes = factory.LazyFunction( lambda: generate_peer_id_from(default_key_pair_factory()) )
class SwarmFactory(factory.Factory): class Meta: model = Swarm class Params: key_pair = factory.LazyFunction(default_key_pair_factory) security_protocol = DEFAULT_SECURITY_PROTOCOL_ID muxer_opt = factory.LazyFunction(default_muxer_transport_factory) peer_id = factory.LazyAttribute( lambda o: generate_peer_id_from(o.key_pair)) peerstore = factory.LazyAttribute( lambda o: initialize_peerstore_with_our_keypair(o.peer_id, o.key_pair)) upgrader = factory.LazyAttribute(lambda o: TransportUpgrader( (security_options_factory_factory(o.security_protocol))(o.key_pair), o.muxer_opt, )) transport = factory.LazyFunction(TCP) @classmethod @asynccontextmanager async def create_and_listen( cls, key_pair: KeyPair = None, security_protocol: TProtocol = None, muxer_opt: TMuxerOptions = None, ) -> AsyncIterator[Swarm]: # `factory.Factory.__init__` does *not* prepare a *default value* if we pass # an argument explicitly with `None`. If an argument is `None`, we don't pass it to # `factory.Factory.__init__`, in order to let the function initialize it. optional_kwargs: Dict[str, Any] = {} if key_pair is not None: optional_kwargs["key_pair"] = key_pair if security_protocol is not None: optional_kwargs["security_protocol"] = security_protocol if muxer_opt is not None: optional_kwargs["muxer_opt"] = muxer_opt swarm = cls(**optional_kwargs) async with background_trio_service(swarm): await swarm.listen(LISTEN_MADDR) yield swarm @classmethod @asynccontextmanager async def create_batch_and_listen( cls, number: int, security_protocol: TProtocol = None, muxer_opt: TMuxerOptions = None, ) -> AsyncIterator[Tuple[Swarm, ...]]: async with AsyncExitStack() as stack: ctx_mgrs = [ await stack.enter_async_context( cls.create_and_listen(security_protocol=security_protocol, muxer_opt=muxer_opt)) for _ in range(number) ] yield tuple(ctx_mgrs)
class SwarmFactory(factory.Factory): class Meta: model = Swarm class Params: is_secure = False key_pair = factory.LazyFunction(generate_new_rsa_identity) muxer_opt = {MPLEX_PROTOCOL_ID: Mplex} peer_id = factory.LazyAttribute(lambda o: generate_peer_id_from(o.key_pair)) peerstore = factory.LazyAttribute( lambda o: initialize_peerstore_with_our_keypair(o.peer_id, o.key_pair) ) upgrader = factory.LazyAttribute( lambda o: TransportUpgrader( security_transport_factory(o.is_secure, o.key_pair), o.muxer_opt ) ) transport = factory.LazyFunction(TCP) @classmethod async def create_and_listen( cls, is_secure: bool, key_pair: KeyPair = None, muxer_opt: TMuxerOptions = None ) -> Swarm: # `factory.Factory.__init__` does *not* prepare a *default value* if we pass # an argument explicitly with `None`. If an argument is `None`, we don't pass it to # `factory.Factory.__init__`, in order to let the function initialize it. optional_kwargs: Dict[str, Any] = {} if key_pair is not None: optional_kwargs["key_pair"] = key_pair if muxer_opt is not None: optional_kwargs["muxer_opt"] = muxer_opt swarm = cls(is_secure=is_secure, **optional_kwargs) await swarm.listen(LISTEN_MADDR) return swarm @classmethod async def create_batch_and_listen( cls, is_secure: bool, number: int, muxer_opt: TMuxerOptions = None ) -> Tuple[Swarm, ...]: # Ignore typing since we are removing asyncio soon return await asyncio.gather( # type: ignore *[ cls.create_and_listen(is_secure=is_secure, muxer_opt=muxer_opt) for _ in range(number) ] )