class Allocation: """Payment allocation managment. """ def __init__(self, appkey: Optional[str] = None): self._cli = Configuration(app_key=appkey) @async_run async def new(self, amount: str): console = Console() async with self._cli.payment() as p: p = Payment(p) free_allocation = await p.new_allocation(amount=Decimal(amount)).detach() console.print(free_allocation) @async_run async def list(self, details: bool = False): "Lists current active payment allocation" console = Console() console.print(f"[bold]details[/bold]: {details}") table = Table(show_header=True, header_style="bold yellow") table.add_column("Id") table.add_column("Amount") table.add_column("Expires") async with self._cli.payment() as p: p = Payment(p) async for allocation in p.allocations(): table.add_row( allocation.id, str(allocation.amount), str(allocation.expires) if allocation.expires else None, ) if table.row_count: console.print(table) else: console.print("[bold]No allocations[/bold]") @async_run async def clear(self): "Removes all active payment allocations" console = Console() async with self._cli.payment() as client: p = Payment(client) allocations = [a async for a in p.allocations()] for allocation in track(allocations, description="cleaning allocations"): await allocation.delete() await sleep(0.2) console.print(f"{len(allocations)} removed")
class Demand: """Offer subscription managment. """ def __init__(self, appkey: Optional[str] = None): self._cli = Configuration(app_key=appkey) self.create = Create @async_run async def list(self, only_expired: bool = False): """Lists all active demands""" console = Console() async with self._cli.market() as client: market_api = Market(client) it: int = 0 async for demand in market_api.subscriptions(): it += 1 console.print(demand.details.to_dict().items()) console.print() console.print(f"{it} demands running") @async_run async def clear(self, only_expired: bool = False): """Removes demands. By default removes all demands. :param only_expired: removes only expired demands. """ console = Console() it = 0 with Progress(console=console) as progress: tid = progress.add_task("dropping demands", start=False) async with self._cli.market() as client: market_api = Market(client) async for demand in market_api.subscriptions(): await demand.delete() it += 1 progress.advance(tid) await sleep(0.2) progress.update(tid, completed=True) console.print(f"{it} demands removed")
async def list_offers(conf: Configuration): async with conf.market() as client: market_api = Market(client) dbuild = DemandBuilder() dbuild.add(yp.Identification(name="some scannig node", subnet_tag="testnet")) dbuild.add(yp.Activity(expiration=datetime.now(timezone.utc))) async with market_api.subscribe(dbuild.props, dbuild.cons) as subscription: async for event in subscription.events(): print(f"Offer: {event.id}") print(f"from {event.issuer}") print(f"props {json.dumps(event.props, indent=4)}") print("\n\n") print("done")
def main(): subnet = "goth" enable_default_logger() try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for( renegotiate_offers( Configuration(), subnet_tag=subnet, ), timeout=140, )) except TimeoutError: print("Main timeout triggered :(")
def main(): parser = utils.build_parser("List offers") args = parser.parse_args() subnet = args.subnet_tag sys.stderr.write(f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n") enable_default_logger() try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for( list_offers( Configuration(), subnet_tag=subnet, ), timeout=4, ) ) except TimeoutError: pass
async def list_offers(conf: Configuration, subnet_tag: str): async with conf.market() as client: market_api = Market(client) dbuild = DemandBuilder() dbuild.add(yp.NodeInfo( name="Golem Stats Indexer", subnet_tag=subnet_tag)) dbuild.add(yp.Activity(expiration=datetime.now(timezone.utc))) async with market_api.subscribe(dbuild.properties, dbuild.constraints) as subscription: async for event in subscription.events(): if event.props['golem.runtime.name'] != "wasmtime": if event.issuer in str(test): continue else: data = event.props if event.props['golem.runtime.name'] == "gminer": try: data["wallet"] = event.props['golem.com.payment.platform.polygon-polygon-glm.address'] except: data['wallet'] = event.props["golem.com.payment.platform.erc20-polygon-glm.address"] data['golem.node.debug.subnet'] = "Thorg" data['id'] = event.issuer test.append(json.dumps(data)) if event.props['golem.runtime.name'] == "hminer": data['wallet'] = event.props['golem.com.payment.platform.polygon-polygon-glm.address'] data['golem.node.debug.subnet'] = "Thorg" data['id'] = event.issuer test.append(json.dumps(data)) if "golem.com.payment.platform.zksync-mainnet-glm.address" in str(event.props): data['wallet'] = event.props['golem.com.payment.platform.zksync-mainnet-glm.address'] elif "golem.com.payment.platform.zksync-rinkeby-tglm.address" in str(event.props): data['wallet'] = event.props['golem.com.payment.platform.zksync-rinkeby-tglm.address'] elif "golem.com.payment.platform.erc20-mainnet-glm.address" in str(event.props): data['wallet'] = event.props['golem.com.payment.platform.erc20-mainnet-glm.address'] elif "golem.com.payment.platform.erc20-polygon-glm.address" in str(event.props): data['wallet'] = event.props['golem.com.payment.platform.erc20-polygon-glm.address'] elif "golem.com.payment.platform.erc20-rinkeby-tglm.address" in str(event.props): data['wallet'] = event.props['golem.com.payment.platform.erc20-rinkeby-tglm.address'] data['id'] = event.issuer test.append(json.dumps(data))
def main(): import pathlib import sys parent_directory = pathlib.Path(__file__).resolve().parent.parent sys.stderr.write(f"Adding {parent_directory} to sys.path.\n") sys.path.append(str(parent_directory)) import utils parser = utils.build_parser("List offers") args = parser.parse_args() subnet = args.subnet_tag sys.stderr.write(f"Using subnet: {utils.TEXT_COLOR_YELLOW}{subnet}{utils.TEXT_COLOR_DEFAULT}\n") enable_default_logger() try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for(list_offers(Configuration(), subnet_tag=subnet,), timeout=4,) ) except TimeoutError: pass
def __init__(self, appkey: Optional[str] = None): self._cli = Configuration(app_key=appkey) self.create = Create
async def yapapi_payment(request): conf = Configuration(app_key=request.config.getvalue("yaApiKey")) async with conf.payment() as p: yield Payment(p)
class Invoices: """Invoice managment. """ def __init__(self, appkey: Optional[str] = None): self._cli = Configuration(app_key=appkey) @async_run async def incoming(self): console = Console() async with self._cli.payment() as client: p = Payment(client) async for invoice in p.incoming_invoices(): console.print(invoice) console.print("done") @async_run async def accept(self, allocation_id: str, invoice_id: str): """ Accepts given `invoice_id` with `allocation_id` :param allocation_id: Allocation from which invoice will be paid. see `allocation list`. :param invoice_id: Invoice identifier. """ console = Console() async with self._cli.payment() as client: p = Payment(client) invoice = await p.invoice(invoice_id) allocation = await p.allocation(allocation_id) await invoice.accept(amount=invoice.amount, allocation=allocation) console.print("done") @async_run async def list(self, by_status: Optional[str] = None): """ Lists all invoices. """ from rich.columns import Columns from rich.text import Text def status_to_color(status: payment.InvoiceStatus) -> Optional[str]: return INVOICE_STATUS_COLOR.get(str(status), None) def filter_invoice(invoice: payment.Invoice) -> bool: if by_status: return str(invoice.status) == by_status return True def format_invoice(invoice: payment.Invoice): status_style = status_to_color(invoice.status) or "" table = Table( "[yellow]Attribute[/yellow]", "[yellow]Value[/yellow]", header_style="bold yellow", title=invoice.invoice_id, style=status_style, title_style=status_style, ) table.add_row(Text.assemble("issuer", style="bold"), invoice.issuer_id) date_txt = str(invoice.timestamp.date()) time_txt = str(invoice.timestamp.time()) table.add_row("ts", f"{date_txt} [dim]{time_txt}[/dim]") table.add_row("amount", invoice.amount) table.add_row("status", Text.assemble(str(invoice.status), style=status_style)) return table console = Console() async with self._cli.payment() as client: p = Payment(client) console.print( Columns( [ format_invoice(invoice) async for invoice in p.invoices() if filter_invoice(invoice) ], width=60, padding=(2, 1), ) )
from yapapi import props as yp from yapapi.props.builder import DemandBuilder from datetime import datetime, timezone import json import asyncio from asyncio import TimeoutError async def list_offers(conf: Configuration): async with conf.market() as client: market_api = Market(client) dbuild = DemandBuilder() dbuild.add(yp.Identification(name="some scannig node", subnet_tag="testnet")) dbuild.add(yp.Activity(expiration=datetime.now(timezone.utc))) async with market_api.subscribe(dbuild.props, dbuild.cons) as subscription: async for event in subscription.events(): print(f"Offer: {event.id}") print(f"from {event.issuer}") print(f"props {json.dumps(event.props, indent=4)}") print("\n\n") print("done") try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for(list_offers(Configuration()), timeout=4) ) except TimeoutError: pass
def main(): try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for( list_offers( Configuration(), subnet_tag="public-beta", ), timeout=15, ) ) except TimeoutError: pass try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for( list_offers( Configuration(), subnet_tag="devnet-beta.1", ), timeout=15, ) ) except TimeoutError: pass try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for( list_offers( Configuration(), subnet_tag="aarch64-network", ), timeout=15, ) ) except TimeoutError: pass try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for( list_offers( Configuration(), subnet_tag="LazySubnet", ), timeout=15, ) ) except TimeoutError: pass try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for( list_offers( Configuration(), subnet_tag="devnet-beta.2", ), timeout=15, ) ) except TimeoutError: pass try: asyncio.get_event_loop().run_until_complete( asyncio.wait_for( list_offers( Configuration(), subnet_tag="devnet-beta", ), timeout=15, ) ) except TimeoutError: pass serialized = json.dumps(test) if len(test) > 580: r = redis.Redis(host='redis', port=6379, db=0) content = r.set("offers", serialized)
async def renegotiate_offers(conf: Configuration, subnet_tag: str): """Rejects every proposal & then renegotiates it""" async with conf.market() as client: market_api = Market(client) dbuild = DemandBuilder() dbuild.add( yp.NodeInfo(name="some renegotiating node", subnet_tag=subnet_tag)) dbuild.add( yp.Activity( expiration=datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(minutes=30))) async with market_api.subscribe(dbuild.properties, dbuild.constraints) as subscription: issuers = set() proposals = 0 rejected_proposals = set() # Already rejected, don't reject again async for event in subscription.events(): node_name = event.props.get("golem.node.id.name") proposal_id = event._proposal.proposal.proposal_id print(f"\n[{node_name}] {'*'*15} {proposal_id}") prev_proposal_id = event._proposal.proposal.prev_proposal_id print(f"[{node_name}] prev_proposal_id: {prev_proposal_id}") if not event.is_draft: if proposals > PROPOSALS_LIMIT: print(f"[node_name] Skipping additional proposal") break await _respond(event, dbuild) proposals += 1 issuers.add(event.issuer) print( f"[{node_name}] Responded. proposals={proposals}, issuers={len(issuers)}" ) continue print( f"[{node_name}] Offer: {proposal_id} from {event.issuer} is_draft: {event.is_draft}" ) if prev_proposal_id not in rejected_proposals: await event.reject() print( f"[{node_name}] Rejected {len(rejected_proposals)}. id: {proposal_id}" ) await asyncio.sleep(1) print(f"[{node_name}] Renegotiating. id: {proposal_id}") new_offer_id = await _respond(event, dbuild) print(f"[{node_name}] new_offer_id: {new_offer_id}") rejected_proposals.add(new_offer_id) continue print(".create_agreement()") agreement = await event.create_agreement() print(".confirm()") confirm_result = await agreement.confirm() print(f"[{node_name}] agreement.confirm(): {confirm_result}") if confirm_result: terminate_reason = { "message": "Work cancelled", "golem.requestor.code": "Cancelled", } terminate_result = await agreement.terminate( terminate_reason) print(f"agreement.terminate(): {terminate_result}") print("All done")