highperfocused/nostrdvm
1
0
Fork 0
mirror of https://github.com/believethehype/nostrdvm.git synced 2025-11-29 11:46:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

allow external dvms to be added to the bot

Browse Source
This commit is contained in:
Believethehype
2023-11-29 15:09:35 +01:00
parent d6a6c4dcbb
commit 42b3d763f1
14 changed files with 178 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
bot/bot.py
View File

@@ -9,15 +9,16 @@ from nostr_sdk import (Keys, Client, Timestamp, Filter, nip04_decrypt, HandleNot
Options, Tag, Event, nip04_encrypt) Options, Tag, Event, nip04_encrypt)
from utils.admin_utils import admin_make_database_updates from utils.admin_utils import admin_make_database_updates
from utils.backend_utils import get_amount_per_task
from utils.database_utils import get_or_add_user, update_user_balance, create_sql_table, update_sql_table, User from utils.database_utils import get_or_add_user, update_user_balance, create_sql_table, update_sql_table, User
from utils.definitions import EventDefinitions from utils.definitions import EventDefinitions
from utils.nip89_utils import nip89_fetch_events_pubkey
from utils.nostr_utils import send_event from utils.nostr_utils import send_event
from utils.zap_utils import parse_zap_event_tags, pay_bolt11_ln_bits, zap from utils.zap_utils import parse_zap_event_tags, pay_bolt11_ln_bits, zap
class Bot: class Bot:
job_list: list job_list: list
# This is a simple list just to keep track which events we created and manage, so we don't pay for other requests # This is a simple list just to keep track which events we created and manage, so we don't pay for other requests
def __init__(self, dvm_config, admin_config=None): def __init__(self, dvm_config, admin_config=None):
self.NAME = "Bot" self.NAME = "Bot"
@@ -85,33 +86,25 @@ class Bot:
if decrypted_text[0].isdigit(): if decrypted_text[0].isdigit():
index = int(decrypted_text.split(' ')[0]) - 1 index = int(decrypted_text.split(' ')[0]) - 1
task = self.dvm_config.SUPPORTED_DVMS[index].TASK
if decrypted_text.split(" ")[1].lower() == "info": if decrypted_text.split(" ")[1].lower() == "info":
nip89 = self.dvm_config.SUPPORTED_DVMS[index].dvm_config.NIP89 info = print_dvm_info(self.client, index)
time.sleep(2.0)
if info is not None:
nip89content = json.loads(nip89.content)
info = ""
if nip89content.get("name"):
info += "Name: " + nip89content.get("name") + "\n"
info += nip89content.get("image")+ "\n"
info += "About:\n" + nip89content.get("about") + "\n"
params = nip89content["nip90Params"]
print(params)
info += "\nParameters:\n"
for param in params:
info += "-" + param + '\n'
info += "Required: " + str(params[param]['required']) + '\n'
info += "Possible Values: " + json.dumps(params[param]['values']) + '\n\n'
evt = EventBuilder.new_encrypted_direct_msg(self.keys, nostr_event.pubkey(), evt = EventBuilder.new_encrypted_direct_msg(self.keys, nostr_event.pubkey(),
info, None).to_event(self.keys) info, None).to_event(self.keys)
send_event(evt, client=self.client, dvm_config=dvm_config) else:
evt = EventBuilder.new_encrypted_direct_msg(self.keys, nostr_event.pubkey(),
"No NIP89 Info found for " +
self.dvm_config.SUPPORTED_DVMS[index].NAME,
None).to_event(self.keys)
send_event(evt, client=self.client, dvm_config=dvm_config)
print(nip89content)
else: else:
print("[" + self.NAME + "] Request from " + str(user.name) + " (" + str(user.nip05) + ", Balance: " task = self.dvm_config.SUPPORTED_DVMS[index].TASK
print("[" + self.NAME + "] Request from " + str(user.name) + " (" + str(
user.nip05) + ", Balance: "
+ str(user.balance) + " Sats) Task: " + str(task)) + str(user.balance) + " Sats) Task: " + str(task))
if user.isblacklisted: if user.isblacklisted:
@@ -129,13 +122,10 @@ class Bot:
input_type = "url" input_type = "url"
i_tag = Tag.parse(["i", input, input_type]) i_tag = Tag.parse(["i", input, input_type])
#bid = str(self.dvm_config.SUPPORTED_DVMS[index].FIX_COST * 1000)
#bid_tag = Tag.parse(['bid', bid, bid])
relays_tag = Tag.parse(["relays", json.dumps(self.dvm_config.RELAY_LIST)]) relays_tag = Tag.parse(["relays", json.dumps(self.dvm_config.RELAY_LIST)])
alt_tag = Tag.parse(["alt", self.dvm_config.SUPPORTED_DVMS[index].TASK]) alt_tag = Tag.parse(["alt", self.dvm_config.SUPPORTED_DVMS[index].TASK])
tags = [i_tag.as_vec(), relays_tag.as_vec(), alt_tag.as_vec()] tags = [i_tag.as_vec(), relays_tag.as_vec(), alt_tag.as_vec()]
remaining_text = command.replace(input, "") remaining_text = command.replace(input, "")
print(remaining_text) print(remaining_text)
params = remaining_text.rstrip().split(" -") params = remaining_text.rstrip().split(" -")
@@ -269,7 +259,8 @@ class Bot:
amount_msats = int(tag.as_vec()[1]) amount_msats = int(tag.as_vec()[1])
amount = int(amount_msats / 1000) amount = int(amount_msats / 1000)
entry = next((x for x in self.job_list if x['event_id'] == etag), None) entry = next((x for x in self.job_list if x['event_id'] == etag), None)
if entry is not None and entry['is_paid'] is False and entry['dvm_key'] == nostr_event.pubkey().to_hex(): if entry is not None and entry['is_paid'] is False and entry[
'dvm_key'] == nostr_event.pubkey().to_hex():
# if we get a bolt11, we pay and move on # if we get a bolt11, we pay and move on
user = get_or_add_user(db=self.dvm_config.DB, npub=entry["npub"], user = get_or_add_user(db=self.dvm_config.DB, npub=entry["npub"],
client=self.client, config=self.dvm_config) client=self.client, config=self.dvm_config)
@@ -287,19 +278,22 @@ class Bot:
+ " Sats.\n", + " Sats.\n",
None).to_event(self.keys) None).to_event(self.keys)
print("[" + self.NAME + "] Replying " + user.name + " with \"scheduled\" confirmation") print(
"[" + self.NAME + "] Replying " + user.name + " with \"scheduled\" confirmation")
send_event(evt, client=self.client, dvm_config=dvm_config) send_event(evt, client=self.client, dvm_config=dvm_config)
else: else:
print("Bot payment-required") print("Bot payment-required")
evt = EventBuilder.new_encrypted_direct_msg(self.keys, PublicKey.from_hex(entry["npub"]), evt = EventBuilder.new_encrypted_direct_msg(self.keys,
"Current balance: " + str(user.balance) + " Sats. Balance of "+ str(amount) +" Sats required. Please zap me with at least " + PublicKey.from_hex(entry["npub"]),
"Current balance: " + str(
user.balance) + " Sats. Balance of " + str(
amount) + " Sats required. Please zap me with at least " +
str(int(amount - user.balance)) str(int(amount - user.balance))
+ " Sats, then try again.", + " Sats, then try again.",
None).to_event(self.keys) None).to_event(self.keys)
send_event(evt, client=self.client, dvm_config=dvm_config) send_event(evt, client=self.client, dvm_config=dvm_config)
return return
if len(tag.as_vec()) > 2: if len(tag.as_vec()) > 2:
bolt11 = tag.as_vec()[2] bolt11 = tag.as_vec()[2]
# else we create a zap # else we create a zap
@@ -390,6 +384,28 @@ class Bot:
self.client.handle_notifications(NotificationHandler()) self.client.handle_notifications(NotificationHandler())
def print_dvm_info(client, index):
pubkey = self.dvm_config.SUPPORTED_DVMS[index].dvm_config.PUBLIC_KEY
kind = self.dvm_config.SUPPORTED_DVMS[index].KIND
nip89content_str = nip89_fetch_events_pubkey(client, pubkey, kind)
print(nip89content_str)
if nip89content_str is not None:
nip89content = json.loads(nip89content_str)
info = ""
if nip89content.get("name"):
info += "Name: " + nip89content.get("name") + "\n"
info += nip89content.get("image") + "\n"
info += "About:\n" + nip89content.get("about") + "\n"
params = nip89content["nip90Params"]
info += "\nParameters:\n"
for param in params:
info += "-" + param + '\n'
info += "Required: " + str(params[param]['required']) + '\n'
info += "Possible Values: " + json.dumps(params[param]['values']) + '\n\n'
return info
return None
try: try:
while True: while True:
time.sleep(1.0) time.sleep(1.0)
@@ -398,7 +414,3 @@ class Bot:
os.kill(os.getpid(), signal.SIGTERM) os.kill(os.getpid(), signal.SIGTERM)
def run(self):
bot = Bot
nostr_dvm_thread = Thread(target=bot, args=[self.dvm_config])
nostr_dvm_thread.start()

37
core/dvm.py
View File

@@ -98,12 +98,11 @@ class DVM:
if user.isblacklisted: if user.isblacklisted:
send_job_status_reaction(nip90_event, "error", client=self.client, dvm_config=self.dvm_config) send_job_status_reaction(nip90_event, "error", client=self.client, dvm_config=self.dvm_config)
print("[" + self.dvm_config.NIP89.name + "] Request by blacklisted user, skipped") print("[" + self.dvm_config.NIP89.NAME + "] Request by blacklisted user, skipped")
elif task_supported: elif task_supported:
print("[" + self.dvm_config.NIP89.name + "] Received new Request: " + task + " from " + user.name) print("[" + self.dvm_config.NIP89.NAME + "] Received new Request: " + task + " from " + user.name)
duration = input_data_file_duration(nip90_event, dvm_config=self.dvm_config, client=self.client) duration = input_data_file_duration(nip90_event, dvm_config=self.dvm_config, client=self.client)
print("File Duration: " + str(duration))
amount = get_amount_per_task(task, self.dvm_config, duration) amount = get_amount_per_task(task, self.dvm_config, duration)
if amount is None: if amount is None:
return return
@@ -125,7 +124,7 @@ class DVM:
# if user is whitelisted or task is free, just do the job # if user is whitelisted or task is free, just do the job
if user.iswhitelisted or task_is_free or cashu_redeemed: if user.iswhitelisted or task_is_free or cashu_redeemed:
print( print(
"[" + self.dvm_config.NIP89.name + "] Free task or Whitelisted for task " + task + "[" + self.dvm_config.NIP89.NAME + "] Free task or Whitelisted for task " + task +
". Starting processing..") ". Starting processing..")
send_job_status_reaction(nip90_event, "processing", True, 0, send_job_status_reaction(nip90_event, "processing", True, 0,
@@ -142,7 +141,7 @@ class DVM:
lastactive=Timestamp.now().as_secs()) lastactive=Timestamp.now().as_secs())
print( print(
"[" + self.dvm_config.NIP89.name + "] Using user's balance for task: " + task + "[" + self.dvm_config.NIP89.NAME + "] Using user's balance for task: " + task +
". Starting processing.. New balance is: " + str(balance)) ". Starting processing.. New balance is: " + str(balance))
send_job_status_reaction(nip90_event, "processing", True, 0, send_job_status_reaction(nip90_event, "processing", True, 0,
@@ -158,7 +157,7 @@ class DVM:
bid = int(tag.as_vec()[1]) bid = int(tag.as_vec()[1])
print( print(
"[" + self.dvm_config.NIP89.name + "] Payment required: New Nostr " + task + " Job event: " "[" + self.dvm_config.NIP89.NAME + "] Payment required: New Nostr " + task + " Job event: "
+ nip90_event.as_json()) + nip90_event.as_json())
if bid > 0: if bid > 0:
bid_offer = int(bid / 1000) bid_offer = int(bid / 1000)
@@ -169,19 +168,19 @@ class DVM:
else: # If there is no bid, just request server rate from user else: # If there is no bid, just request server rate from user
print( print(
"[" + self.dvm_config.NIP89.name + "] Requesting payment for Event: " + "[" + self.dvm_config.NIP89.NAME + "] Requesting payment for Event: " +
nip90_event.id().to_hex()) nip90_event.id().to_hex())
send_job_status_reaction(nip90_event, "payment-required", send_job_status_reaction(nip90_event, "payment-required",
False, int(amount), client=self.client, dvm_config=self.dvm_config) False, int(amount), client=self.client, dvm_config=self.dvm_config)
# else: # else:
# print("[" + self.dvm_config.NIP89.name + "] Task " + task + " not supported on this DVM, skipping..") # print("[" + self.dvm_config.NIP89.NAME + "] Task " + task + " not supported on this DVM, skipping..")
def handle_zap(zap_event): def handle_zap(zap_event):
try: try:
invoice_amount, zapped_event, sender, message, anon = parse_zap_event_tags(zap_event, invoice_amount, zapped_event, sender, message, anon = parse_zap_event_tags(zap_event,
self.keys, self.keys,
self.dvm_config.NIP89.name, self.dvm_config.NIP89.NAME,
self.client, self.dvm_config) self.client, self.dvm_config)
user = get_or_add_user(db=self.dvm_config.DB, npub=sender, client=self.client, config=self.dvm_config) user = get_or_add_user(db=self.dvm_config.DB, npub=sender, client=self.client, config=self.dvm_config)
@@ -211,7 +210,7 @@ class DVM:
print("Zap received for NIP90 task: " + str(invoice_amount) + " Sats from " + str( print("Zap received for NIP90 task: " + str(invoice_amount) + " Sats from " + str(
user.name)) user.name))
if amount <= invoice_amount: if amount <= invoice_amount:
print("[" + self.dvm_config.NIP89.name + "] Payment-request fulfilled...") print("[" + self.dvm_config.NIP89.NAME + "] Payment-request fulfilled...")
send_job_status_reaction(job_event, "processing", client=self.client, send_job_status_reaction(job_event, "processing", client=self.client,
dvm_config=self.dvm_config) dvm_config=self.dvm_config)
indices = [i for i, x in enumerate(self.job_list) if indices = [i for i, x in enumerate(self.job_list) if
@@ -237,26 +236,26 @@ class DVM:
send_job_status_reaction(job_event, "payment-rejected", send_job_status_reaction(job_event, "payment-rejected",
False, invoice_amount, client=self.client, False, invoice_amount, client=self.client,
dvm_config=self.dvm_config) dvm_config=self.dvm_config)
print("[" + self.dvm_config.NIP89.name + "] Invoice was not paid sufficiently") print("[" + self.dvm_config.NIP89.NAME + "] Invoice was not paid sufficiently")
elif zapped_event.kind() in EventDefinitions.ANY_RESULT: elif zapped_event.kind() in EventDefinitions.ANY_RESULT:
print("[" + self.dvm_config.NIP89.name + "] " print("[" + self.dvm_config.NIP89.NAME + "] "
"Someone zapped the result of an exisiting Task. Nice") "Someone zapped the result of an exisiting Task. Nice")
elif not anon: elif not anon:
print("[" + self.dvm_config.NIP89.name + "] Note Zap received for DVM balance: " + print("[" + self.dvm_config.NIP89.NAME + "] Note Zap received for DVM balance: " +
str(invoice_amount) + " Sats from " + str(user.name)) str(invoice_amount) + " Sats from " + str(user.name))
update_user_balance(self.dvm_config.DB, sender, invoice_amount, client=self.client, update_user_balance(self.dvm_config.DB, sender, invoice_amount, client=self.client,
config=self.dvm_config) config=self.dvm_config)
# a regular note # a regular note
elif not anon: elif not anon:
print("[" + self.dvm_config.NIP89.name + "] Profile Zap received for DVM balance: " + print("[" + self.dvm_config.NIP89.NAME + "] Profile Zap received for DVM balance: " +
str(invoice_amount) + " Sats from " + str(user.name)) str(invoice_amount) + " Sats from " + str(user.name))
update_user_balance(self.dvm_config.DB, sender, invoice_amount, client=self.client, update_user_balance(self.dvm_config.DB, sender, invoice_amount, client=self.client,
config=self.dvm_config) config=self.dvm_config)
except Exception as e: except Exception as e:
print("[" + self.dvm_config.NIP89.name + "] Error during content decryption: " + str(e)) print("[" + self.dvm_config.NIP89.NAME + "] Error during content decryption: " + str(e))
def check_event_has_not_unfinished_job_input(nevent, append, client, dvmconfig): def check_event_has_not_unfinished_job_input(nevent, append, client, dvmconfig):
task_supported, task = check_task_is_supported(nevent, client, config=dvmconfig) task_supported, task = check_task_is_supported(nevent, client, config=dvmconfig)
@@ -349,7 +348,7 @@ class DVM:
reply_event = EventBuilder(original_event.kind() + 1000, str(content), reply_tags).to_event(self.keys) reply_event = EventBuilder(original_event.kind() + 1000, str(content), reply_tags).to_event(self.keys)
send_event(reply_event, client=self.client, dvm_config=self.dvm_config) send_event(reply_event, client=self.client, dvm_config=self.dvm_config)
print("[" + self.dvm_config.NIP89.name + "] " + str( print("[" + self.dvm_config.NIP89.NAME + "] " + str(
original_event.kind() + 1000) + " Job Response event sent: " + reply_event.as_json()) original_event.kind() + 1000) + " Job Response event sent: " + reply_event.as_json())
def send_job_status_reaction(original_event, status, is_paid=True, amount=0, client=None, def send_job_status_reaction(original_event, status, is_paid=True, amount=0, client=None,
@@ -433,7 +432,7 @@ class DVM:
keys = Keys.from_sk_str(dvm_config.PRIVATE_KEY) keys = Keys.from_sk_str(dvm_config.PRIVATE_KEY)
reaction_event = EventBuilder(EventDefinitions.KIND_FEEDBACK, str(content), reply_tags).to_event(keys) reaction_event = EventBuilder(EventDefinitions.KIND_FEEDBACK, str(content), reply_tags).to_event(keys)
send_event(reaction_event, client=self.client, dvm_config=self.dvm_config) send_event(reaction_event, client=self.client, dvm_config=self.dvm_config)
print("[" + self.dvm_config.NIP89.name + "]" + ": Sent Kind " + str( print("[" + self.dvm_config.NIP89.NAME + "]" + ": Sent Kind " + str(
EventDefinitions.KIND_FEEDBACK) + " Reaction: " + status + " " + reaction_event.as_json()) EventDefinitions.KIND_FEEDBACK) + " Reaction: " + status + " " + reaction_event.as_json())
return reaction_event.as_json() return reaction_event.as_json()
@@ -468,7 +467,7 @@ class DVM:
send_job_status_reaction(job.event, "processing", True, 0, send_job_status_reaction(job.event, "processing", True, 0,
client=self.client, client=self.client,
dvm_config=self.dvm_config) dvm_config=self.dvm_config)
print("[" + self.dvm_config.NIP89.name + "] doing work from joblist") print("[" + self.dvm_config.NIP89.NAME + "] doing work from joblist")
do_work(job.event) do_work(job.event)
elif ispaid is None: # invoice expired elif ispaid is None: # invoice expired
self.job_list.remove(job) self.job_list.remove(job)
@@ -483,7 +482,7 @@ class DVM:
try: try:
self.jobs_on_hold_list.remove(job) self.jobs_on_hold_list.remove(job)
except: except:
print("[" + self.dvm_config.NIP89.name + "] Error removing Job on Hold from List after expiry") print("[" + self.dvm_config.NIP89.NAME + "] Error removing Job on Hold from List after expiry")
if Timestamp.now().as_secs() > job.timestamp + 60 * 20: # remove jobs to look for after 20 minutes.. if Timestamp.now().as_secs() > job.timestamp + 60 * 20: # remove jobs to look for after 20 minutes..
self.jobs_on_hold_list.remove(job) self.jobs_on_hold_list.remove(job)

28
interfaces/dvmtaskinterface.py
View File

@@ -5,14 +5,14 @@ from nostr_sdk import Keys
from utils.admin_utils import AdminConfig from utils.admin_utils import AdminConfig
from utils.dvmconfig import DVMConfig from utils.dvmconfig import DVMConfig
from utils.nip89_utils import NIP89Announcement, NIP89Config from utils.nip89_utils import NIP89Config
from core.dvm import DVM from core.dvm import DVM
class DVMTaskInterface: class DVMTaskInterface:
NAME: str NAME: str
KIND: int KIND: int
TASK: str TASK: str = ""
FIX_COST: float = 0 FIX_COST: float = 0
PER_UNIT_COST: float = 0 PER_UNIT_COST: float = 0
PRIVATE_KEY: str PRIVATE_KEY: str
@@ -22,11 +22,11 @@ class DVMTaskInterface:
admin_config: AdminConfig admin_config: AdminConfig
def __init__(self, name, dvm_config: DVMConfig, nip89config: NIP89Config, admin_config: AdminConfig = None, def __init__(self, name, dvm_config: DVMConfig, nip89config: NIP89Config, admin_config: AdminConfig = None,
options=None): options=None, task=None):
self.init(name, dvm_config, admin_config, nip89config) self.init(name, dvm_config, admin_config, nip89config, task)
self.options = options self.options = options
def init(self, name, dvm_config, admin_config=None, nip89config=None): def init(self, name, dvm_config, admin_config=None, nip89config=None, task=None):
self.NAME = name self.NAME = name
self.PRIVATE_KEY = dvm_config.PRIVATE_KEY self.PRIVATE_KEY = dvm_config.PRIVATE_KEY
if dvm_config.PUBLIC_KEY == "" or dvm_config.PUBLIC_KEY is None: if dvm_config.PUBLIC_KEY == "" or dvm_config.PUBLIC_KEY is None:
@@ -36,9 +36,15 @@ class DVMTaskInterface:
self.FIX_COST = dvm_config.FIX_COST self.FIX_COST = dvm_config.FIX_COST
if dvm_config.PER_UNIT_COST is not None: if dvm_config.PER_UNIT_COST is not None:
self.PER_UNIT_COST = dvm_config.PER_UNIT_COST self.PER_UNIT_COST = dvm_config.PER_UNIT_COST
if task is not None:
self.TASK = task
dvm_config.SUPPORTED_DVMS = [self] dvm_config.SUPPORTED_DVMS = [self]
dvm_config.DB = "db/" + self.NAME + ".db" dvm_config.DB = "db/" + self.NAME + ".db"
if nip89config.KIND is not None:
self.KIND = nip89config.KIND
dvm_config.NIP89 = self.NIP89_announcement(nip89config) dvm_config.NIP89 = self.NIP89_announcement(nip89config)
self.dvm_config = dvm_config self.dvm_config = dvm_config
self.admin_config = admin_config self.admin_config = admin_config
@@ -49,12 +55,12 @@ class DVMTaskInterface:
nostr_dvm_thread.start() nostr_dvm_thread.start()
def NIP89_announcement(self, nip89config: NIP89Config): def NIP89_announcement(self, nip89config: NIP89Config):
nip89 = NIP89Announcement() nip89 = NIP89Config()
nip89.name = self.NAME nip89.NAME = self.NAME
nip89.kind = self.KIND nip89.KIND = self.KIND
nip89.pk = self.PRIVATE_KEY nip89.PK = self.PRIVATE_KEY
nip89.dtag = nip89config.DTAG nip89.DTAG = nip89config.DTAG
nip89.content = nip89config.CONTENT nip89.CONTENT = nip89config.CONTENT
return nip89 return nip89
def is_input_supported(self, tags) -> bool: def is_input_supported(self, tags) -> bool:

18
main.py
View File

@@ -11,7 +11,8 @@ from nostr_sdk import Keys
from bot.bot import Bot from bot.bot import Bot
from playground import build_pdf_extractor, build_googletranslator, build_unstable_diffusion, build_sketcher, \ from playground import build_pdf_extractor, build_googletranslator, build_unstable_diffusion, build_sketcher, \
build_dalle, \ build_dalle, \
build_whisperx, build_libretranslator build_whisperx, build_libretranslator, build_external_dvm
from utils.definitions import EventDefinitions
from utils.dvmconfig import DVMConfig from utils.dvmconfig import DVMConfig
@@ -73,8 +74,19 @@ def run_nostr_dvm_with_local_config():
bot_config.SUPPORTED_DVMS.append(dalle) bot_config.SUPPORTED_DVMS.append(dalle)
dalle.run() dalle.run()
bot = Bot(bot_config) # Spawn DVM7.. oh wait, actually we don't spawn a new DVM, we use the dvmtaskinterface to define an external dvm by providing some info about it, such as
bot.run() # their pubkey, a name, task, kind etc.
libretranslate_external = build_external_dvm(name="External DVM test",
pubkey="08fd6bdb17cb2c8a87f8d50653238cb46e26cd44948c474f51dae5f138609da6",
task="translation",
kind=EventDefinitions.KIND_NIP90_TRANSLATE_TEXT,
fix_cost=0, per_unit_cost=0)
bot_config.SUPPORTED_DVMS.append(libretranslate_external)
#Don't run it, it's on someone else's machine and we simply make the bot aware of it.
Bot(bot_config)
# Keep the main function alive for libraries that require it, like openai # Keep the main function alive for libraries that require it, like openai
try: try:

22
playground.py
View File

@@ -11,6 +11,7 @@ from tasks.textextractionpdf import TextExtractionPDF
from tasks.translation_google import TranslationGoogle from tasks.translation_google import TranslationGoogle
from tasks.translation_libretranslate import TranslationLibre from tasks.translation_libretranslate import TranslationLibre
from utils.admin_utils import AdminConfig from utils.admin_utils import AdminConfig
from utils.definitions import EventDefinitions
from utils.dvmconfig import DVMConfig from utils.dvmconfig import DVMConfig
from utils.nip89_utils import NIP89Config from utils.nip89_utils import NIP89Config
@@ -93,8 +94,7 @@ def build_googletranslator(name):
nip89config = NIP89Config() nip89config = NIP89Config()
nip89config.DTAG = os.getenv("TASK_TRANSLATION_NIP89_DTAG") nip89config.DTAG = os.getenv("TASK_TRANSLATION_NIP89_DTAG")
nip89config.CONTENT = json.dumps(nip89info) nip89config.CONTENT = json.dumps(nip89info)
return TranslationGoogle(name=name, dvm_config=dvm_config, nip89config=nip89config, return TranslationGoogle(name=name, dvm_config=dvm_config, nip89config=nip89config, admin_config=admin_config)
admin_config=admin_config)
def build_libretranslator(name): def build_libretranslator(name):
@@ -160,7 +160,7 @@ def build_unstable_diffusion(name):
nip89config = NIP89Config() nip89config = NIP89Config()
nip89config.DTAG = os.getenv("TASK_IMAGE_GENERATION_NIP89_DTAG") nip89config.DTAG = os.getenv("TASK_IMAGE_GENERATION_NIP89_DTAG")
nip89config.CONTENT = json.dumps(nip89info) nip89config.CONTENT = json.dumps(nip89info)
return ImageGenerationSDXL(name=name, dvm_config=dvm_config, nip89config=nip89config, return ImageGenerationSDXL(name=name, dvm_config=dvm_config, nip89config=nip89config,
admin_config=admin_config, options=options) admin_config=admin_config, options=options)
@@ -194,7 +194,7 @@ def build_whisperx(name):
nip89config = NIP89Config() nip89config = NIP89Config()
nip89config.DTAG = os.getenv("TASK_SPEECH_TO_TEXT_NIP89") nip89config.DTAG = os.getenv("TASK_SPEECH_TO_TEXT_NIP89")
nip89config.CONTENT = json.dumps(nip89info) nip89config.CONTENT = json.dumps(nip89info)
return SpeechToTextWhisperX(name=name, dvm_config=dvm_config, nip89config=nip89config, return SpeechToTextWhisperX(name=name, dvm_config=dvm_config, nip89config=nip89config,
admin_config=admin_config, options=options) admin_config=admin_config, options=options)
@@ -229,7 +229,7 @@ def build_sketcher(name):
nip89config.DTAG = os.getenv("TASK_IMAGE_GENERATION_NIP89_DTAG2") nip89config.DTAG = os.getenv("TASK_IMAGE_GENERATION_NIP89_DTAG2")
nip89config.CONTENT = json.dumps(nip89info) nip89config.CONTENT = json.dumps(nip89info)
# We add an optional AdminConfig for this one, and tell the dvm to rebroadcast its NIP89 # We add an optional AdminConfig for this one, and tell the dvm to rebroadcast its NIP89
return ImageGenerationSDXL(name=name, dvm_config=dvm_config, nip89config=nip89config, return ImageGenerationSDXL(name=name, dvm_config=dvm_config, nip89config=nip89config,
admin_config=admin_config, options=options) admin_config=admin_config, options=options)
@@ -261,20 +261,22 @@ def build_dalle(name):
nip89config.DTAG = os.getenv("TASK_IMAGE_GENERATION_NIP89_DTAG3") nip89config.DTAG = os.getenv("TASK_IMAGE_GENERATION_NIP89_DTAG3")
nip89config.CONTENT = json.dumps(nip89info) nip89config.CONTENT = json.dumps(nip89info)
# We add an optional AdminConfig for this one, and tell the dvm to rebroadcast its NIP89 # We add an optional AdminConfig for this one, and tell the dvm to rebroadcast its NIP89
return ImageGenerationDALLE(name=name, dvm_config=dvm_config, nip89config=nip89config, return ImageGenerationDALLE(name=name, dvm_config=dvm_config, nip89config=nip89config, admin_config=admin_config)
admin_config=admin_config)
def external_dvm(name, pubkey): def build_external_dvm(name, pubkey, task, kind, fix_cost, per_unit_cost):
dvm_config = DVMConfig() dvm_config = DVMConfig()
dvm_config.PUBLIC_KEY = Keys.from_public_key(pubkey).public_key().to_hex() dvm_config.PUBLIC_KEY = PublicKey.from_hex(pubkey).to_hex()
dvm_config.FIX_COST = fix_cost
dvm_config.PER_UNIT_COST = per_unit_cost
nip89info = { nip89info = {
"name": name, "name": name,
} }
nip89config = NIP89Config() nip89config = NIP89Config()
nip89config.KIND = kind
nip89config.CONTENT = json.dumps(nip89info) nip89config.CONTENT = json.dumps(nip89info)
return DVMTaskInterface(name=name, dvm_config=dvm_config, nip89config=nip89config) return DVMTaskInterface(name=name, dvm_config=dvm_config, nip89config=nip89config, task=task)
# Little Gimmick: # Little Gimmick:

4
tasks/textextraction_whisperx.py
View File

@@ -8,7 +8,7 @@ from backends.nova_server import check_nova_server_status, send_request_to_nova_
from interfaces.dvmtaskinterface import DVMTaskInterface from interfaces.dvmtaskinterface import DVMTaskInterface
from utils.admin_utils import AdminConfig from utils.admin_utils import AdminConfig
from utils.dvmconfig import DVMConfig from utils.dvmconfig import DVMConfig
from utils.mediasource_utils import organize_input_data from utils.mediasource_utils import organize_input_data_to_audio
from utils.nip89_utils import NIP89Config from utils.nip89_utils import NIP89Config
from utils.definitions import EventDefinitions from utils.definitions import EventDefinitions
@@ -102,7 +102,7 @@ class SpeechToTextWhisperX(DVMTaskInterface):
except: except:
end_time = float(tag.as_vec()[3]) end_time = float(tag.as_vec()[3])
filepath = organize_input_data(url, input_type, start_time, end_time, dvm_config, client) filepath = organize_input_data_to_audio(url, input_type, start_time, end_time, dvm_config, client)
pathonserver = send_file_to_nova_server(filepath, self.options['nova_server']) pathonserver = send_file_to_nova_server(filepath, self.options['nova_server'])
io_input = { io_input = {

12
tasks/translation_libretranslate.py
View File

@@ -24,8 +24,8 @@ class TranslationLibre(DVMTaskInterface):
FIX_COST: float = 0 FIX_COST: float = 0
def __init__(self, name, dvm_config: DVMConfig, nip89config: NIP89Config, def __init__(self, name, dvm_config: DVMConfig, nip89config: NIP89Config,
admin_config: AdminConfig = None, options=None): admin_config: AdminConfig = None, options=None, task=None):
super().__init__(name, dvm_config, nip89config, admin_config, options) super().__init__(name, dvm_config, nip89config, admin_config, options, task)
def is_input_supported(self, tags): def is_input_supported(self, tags):
for tag in tags: for tag in tags:
@@ -88,10 +88,10 @@ class TranslationLibre(DVMTaskInterface):
reply = json.loads(response.text) reply = json.loads(response.text)
if reply.get("translatedText"): if reply.get("translatedText"):
translated_text = reply['translatedText'] translated_text = reply['translatedText']
#untested
confidence = reply["detectedLanguage"]['confidence'] #confidence = reply["detectedLanguage"]['confidence']
language = reply["detectedLanguage"]['language'] #language = reply["detectedLanguage"]['language']
print(translated_text + "language: " + language + "conf: " + confidence) #print(translated_text + "language: " + language + "conf: " + confidence)
else: else:
return response.text return response.text

1
utils/definitions.py
View File

@@ -5,6 +5,7 @@ from nostr_sdk import Event
class EventDefinitions: class EventDefinitions:
KIND_DM: int = 4 KIND_DM: int = 4
KIND_ZAP: int = 9735 KIND_ZAP: int = 9735
KIND_ANNOUNCEMENT: int = 31990
KIND_NIP94_METADATA: int = 1063 KIND_NIP94_METADATA: int = 1063
KIND_FEEDBACK: int = 7000 KIND_FEEDBACK: int = 7000
KIND_NIP90_EXTRACT_TEXT = 5000 KIND_NIP90_EXTRACT_TEXT = 5000

4
utils/dvmconfig.py
View File

@@ -2,7 +2,7 @@ import os
from nostr_sdk import Keys from nostr_sdk import Keys
from utils.nip89_utils import NIP89Announcement from utils.nip89_utils import NIP89Config
class DVMConfig: class DVMConfig:
@@ -22,7 +22,7 @@ class DVMConfig:
LNBITS_URL = 'https://lnbits.com' LNBITS_URL = 'https://lnbits.com'
DB: str DB: str
NEW_USER_BALANCE: int = 250 # Free credits for new users NEW_USER_BALANCE: int = 250 # Free credits for new users
NIP89: NIP89Announcement NIP89: NIP89Config
SHOW_RESULT_BEFORE_PAYMENT: bool = False # if this is true show results even when not paid right after autoprocess SHOW_RESULT_BEFORE_PAYMENT: bool = False # if this is true show results even when not paid right after autoprocess

17
utils/mediasource_utils.py
View File

@@ -9,7 +9,7 @@ from utils.nostr_utils import get_event_by_id
def input_data_file_duration(event, dvm_config, client, start=0, end=0): def input_data_file_duration(event, dvm_config, client, start=0, end=0):
print("[" + dvm_config.NIP89.name + "] Getting Duration of the Media file..") print("[" + dvm_config.NIP89.NAME + "] Getting Duration of the Media file..")
input_value = "" input_value = ""
input_type = "url" input_type = "url"
for tag in event.tags(): for tag in event.tags():
@@ -17,11 +17,17 @@ def input_data_file_duration(event, dvm_config, client, start=0, end=0):
input_value = tag.as_vec()[1] input_value = tag.as_vec()[1]
input_type = tag.as_vec()[2] input_type = tag.as_vec()[2]
if input_type == "text":
#For now, ingore length of any text, just return 1.
return 1
if input_type == "event": # NIP94 event if input_type == "event": # NIP94 event
evt = get_event_by_id(input_value, client=client, config=dvm_config) evt = get_event_by_id(input_value, client=client, config=dvm_config)
if evt is not None: if evt is not None:
input_value, input_type = check_nip94_event_for_media(evt, input_value, input_type) input_value, input_type = check_nip94_event_for_media(evt, input_value, input_type)
if input_type == "text":
# For now, ingore length of any text, just return 1.
return 1
if input_type == "url": if input_type == "url":
source_type = check_source_type(input_value) source_type = check_source_type(input_value)
@@ -46,9 +52,7 @@ def input_data_file_duration(event, dvm_config, client, start=0, end=0):
return 1 return 1
def organize_input_data_to_audio(input_value, input_type, start, end, dvm_config, client) -> str:
def organize_input_data(input_value, input_type, start, end, dvm_config, client, process=True) -> str:
if input_type == "event": # NIP94 event if input_type == "event": # NIP94 event
evt = get_event_by_id(input_value, client=client, config=dvm_config) evt = get_event_by_id(input_value, client=client, config=dvm_config)
if evt is not None: if evt is not None:
@@ -71,7 +75,6 @@ def organize_input_data(input_value, input_type, start, end, dvm_config, client,
convert_media_length(start, end, duration)) convert_media_length(start, end, duration))
print("New Duration of the Media file: " + str(new_duration)) print("New Duration of the Media file: " + str(new_duration))
# TODO if already in a working format and time is 0 0, dont convert # TODO if already in a working format and time is 0 0, dont convert
print("Converting from " + str(start_time) + " until " + str(end_time)) print("Converting from " + str(start_time) + " until " + str(end_time))
# for now, we cut and convert all files to mp3 # for now, we cut and convert all files to mp3
@@ -81,6 +84,7 @@ def organize_input_data(input_value, input_type, start, end, dvm_config, client,
ffmpegio.audio.write(final_filename, fs, x, overwrite=True) ffmpegio.audio.write(final_filename, fs, x, overwrite=True)
return final_filename return final_filename
def check_nip94_event_for_media(evt, input_value, input_type): def check_nip94_event_for_media(evt, input_value, input_type):
# Parse NIP94 event for url, if found, use it. # Parse NIP94 event for url, if found, use it.
if evt.kind() == 1063: if evt.kind() == 1063:
@@ -92,6 +96,7 @@ def check_nip94_event_for_media(evt, input_value, input_type):
return input_value, input_type return input_value, input_type
def convert_media_length(start: float, end: float, duration: float): def convert_media_length(start: float, end: float, duration: float):
if end == 0.0: if end == 0.0:
end_time = duration end_time = duration

57
utils/nip89_utils.py
View File

@@ -1,18 +1,17 @@
from nostr_sdk import Tag, Keys, EventBuilder from datetime import timedelta
from nostr_sdk import Tag, Keys, EventBuilder, Filter, Alphabet, PublicKey, Event
from utils.definitions import EventDefinitions
from utils.nostr_utils import send_event from utils.nostr_utils import send_event
class NIP89Announcement:
name: str
kind: int
dtag: str
pk: str
content: str
class NIP89Config: class NIP89Config:
DTAG: str DTAG: str = ""
CONTENT: str NAME: str = ""
KIND: int = None
PK: str = ""
CONTENT: str = ""
def nip89_announce_tasks(dvm_config, client): def nip89_announce_tasks(dvm_config, client):
@@ -20,6 +19,38 @@ def nip89_announce_tasks(dvm_config, client):
d_tag = Tag.parse(["d", dvm_config.NIP89.dtag]) d_tag = Tag.parse(["d", dvm_config.NIP89.dtag])
keys = Keys.from_sk_str(dvm_config.NIP89.pk) keys = Keys.from_sk_str(dvm_config.NIP89.pk)
content = dvm_config.NIP89.content content = dvm_config.NIP89.content
event = EventBuilder(31990, content, [k_tag, d_tag]).to_event(keys) event = EventBuilder(EventDefinitions.KIND_ANNOUNCEMENT, content, [k_tag, d_tag]).to_event(keys)
send_event(event, client=client, dvm_config=dvm_config) send_event(event, client=client, dvm_config=dvm_config)
print("Announced NIP 89 for " + dvm_config.NIP89.name) print("Announced NIP 89 for " + dvm_config.NIP89.NAME)
def nip89_fetch_all_dvms(client):
ktags = []
for i in range(5000, 5999):
ktags.append(str(i))
filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).custom_tag(Alphabet.K, ktags)
events = client.get_events_of([filter], timedelta(seconds=5))
for event in events:
print(event.as_json())
def nip89_fetch_events_pubkey(client, pubkey, kind):
ktags = [str(kind)]
# for i in range(5000, 5999):
# ktags.append(str(i))
nip89filter = (Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(PublicKey.from_hex(pubkey)).
custom_tag(Alphabet.K, ktags))
events = client.get_events_of([nip89filter], timedelta(seconds=2))
dvms = {}
for event in events:
if dvms.get(event.pubkey().to_hex()):
if dvms.get(event.pubkey().to_hex()).created_at().as_secs() < event.created_at().as_secs():
dvms[event.pubkey().to_hex()] = event
else:
dvms[event.pubkey().to_hex()] = event
# should be one element of the kind now
for dvm in dvms:
return dvms[dvm].content()

4
utils/nostr_utils.py
View File

@@ -78,7 +78,7 @@ def check_and_decrypt_tags(event, dvm_config):
if is_encrypted: if is_encrypted:
if p != dvm_config.PUBLIC_KEY: if p != dvm_config.PUBLIC_KEY:
print("[" + dvm_config.NIP89.name + "] Task encrypted and not addressed to this DVM, " print("[" + dvm_config.NIP89.NAME + "] Task encrypted and not addressed to this DVM, "
"skipping..") "skipping..")
return None return None
@@ -111,7 +111,7 @@ def check_and_decrypt_own_tags(event, dvm_config):
if is_encrypted: if is_encrypted:
if dvm_config.PUBLIC_KEY != event.pubkey().to_hex(): if dvm_config.PUBLIC_KEY != event.pubkey().to_hex():
print("[" + dvm_config.NIP89.name + "] Task encrypted and not addressed to this DVM, " print("[" + dvm_config.NIP89.NAME + "] Task encrypted and not addressed to this DVM, "
"skipping..") "skipping..")
return None return None

1
utils/output_utils.py
View File

@@ -83,7 +83,6 @@ def post_process_result(anno, original_event):
elif isinstance(anno, NoneType): elif isinstance(anno, NoneType):
return "An error occurred" return "An error occurred"
else: else:
print("Nonetype")
result = replace_broken_words(anno) # TODO result = replace_broken_words(anno) # TODO
return result return result

4
utils/zap_utils.py
View File

@@ -86,7 +86,7 @@ def create_bolt11_ln_bits(sats: int, config: DVMConfig) -> (str, str):
if config.LNBITS_URL == "": if config.LNBITS_URL == "":
return None return None
url = config.LNBITS_URL + "/api/v1/payments" url = config.LNBITS_URL + "/api/v1/payments"
data = {'out': False, 'amount': sats, 'memo': "Nostr-DVM " + config.NIP89.name} data = {'out': False, 'amount': sats, 'memo': "Nostr-DVM " + config.NIP89.NAME}
headers = {'X-API-Key': config.LNBITS_INVOICE_KEY, 'Content-Type': 'application/json', 'charset': 'UTF-8'} headers = {'X-API-Key': config.LNBITS_INVOICE_KEY, 'Content-Type': 'application/json', 'charset': 'UTF-8'}
try: try:
res = requests.post(url, json=data, headers=headers) res = requests.post(url, json=data, headers=headers)
@@ -285,7 +285,7 @@ def redeem_cashu(cashu, required_amount, config, client) -> (bool, str):
err = ("Token value (Payment: " + str(total_amount) + " Sats. Fees: " + err = ("Token value (Payment: " + str(total_amount) + " Sats. Fees: " +
str(fees) + " Sats) below required amount of " + str(required_amount) str(fees) + " Sats) below required amount of " + str(required_amount)
+ " Sats. Cashu token has not been claimed.") + " Sats. Cashu token has not been claimed.")
print("[" + config.NIP89.name + "] " + err) print("[" + config.NIP89.NAME + "] " + err)
return False, err return False, err
if config.LNBITS_INVOICE_KEY != "": if config.LNBITS_INVOICE_KEY != "":