highperfocused/nostrdvm
1
0
Fork 0
mirror of https://github.com/believethehype/nostrdvm.git synced 2025-06-25 11:41:05 +02:00
Code Issues Packages Projects Releases Wiki Activity

update to nostr-sdk 0.38, improve prints

Browse Source
This commit is contained in:
dbth 2024-12-31 14:39:37 +01:00
parent 5033fe0134
commit fbc7361ca5
40 changed files with 137 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
nostr_dvm/bot.py
View File

@ -189,7 +189,7 @@ class Bot:
print(params_as_str)
# and encrypt them
encrypted_params = nip44_encrypt(self.keys.secret_key(),
PublicKey.from_hex(
PublicKey.parse(
self.dvm_config.SUPPORTED_DVMS[
index].PUBLIC_KEY),
params_as_str, Nip44Version.V2)
@ -675,16 +675,12 @@ class Bot:
elif (input.startswith("nevent") or input.startswith("nostr:nevent") or input.startswith("note") or
input.startswith("nostr:note")):
input_type = "event"
if str(input).startswith('note'):
event_id = EventId.from_bech32(input)
elif str(input).startswith("nevent"):
if str(input).startswith("nevent"):
event_id = Nip19Event.from_bech32(input).event_id()
elif str(input).startswith('nostr:note'):
event_id = EventId.from_nostr_uri(input)
elif str(input).startswith("nostr:nevent"):
event_id = Nip19Event.from_nostr_uri(input).event_id()
else:
event_id = EventId.from_hex(input)
event_id = EventId.parse(input)
i_tag = Tag.parse(["i", event_id.to_hex(), input_type])
tags.append(i_tag)
else:

45
nostr_dvm/dvm.py
View File

@ -17,7 +17,7 @@ from nostr_dvm.utils.dvmconfig import DVMConfig
from nostr_dvm.utils.mediasource_utils import input_data_file_duration
from nostr_dvm.utils.nip88_utils import nip88_has_active_subscription
from nostr_dvm.utils.nostr_utils import get_event_by_id, get_referenced_event_by_id, check_and_decrypt_tags, \
send_event_outbox
send_event_outbox, print_send_result
from nostr_dvm.utils.nut_wallet_utils import NutZapWallet
from nostr_dvm.utils.output_utils import build_status_reaction
from nostr_dvm.utils.print_utils import bcolors
@ -432,7 +432,7 @@ class DVM:
print(status)
if job_event.kind() == EventDefinitions.KIND_NIP88_SUBSCRIBE_EVENT:
await send_job_status_reaction(job_event, "subscription-success", client=self.client,
dvm_config=self.dvm_config, user=user)
dvm_config=self.dvm_config)
@ -579,8 +579,8 @@ class DVM:
request_tag = Tag.parse(["request", original_event_as_str])
e_tag = Tag.parse(["e", original_event.id().to_hex()])
p_tag = Tag.parse(["p", original_event.author().to_hex()])
alt_tag = Tag.parse(["alt", "This is the result of a NIP90 DVM AI task with kind " + str(
original_event.kind().as_u16()) + ". The task was: " + original_event.content()])
alt_tag = Tag.parse(["alt", "This is the result of a NIP90 DVM task with kind " + str(
original_event.kind().as_u16())])
status_tag = Tag.parse(["status", "success"])
reply_tags = [request_tag, e_tag, p_tag, alt_tag, status_tag]
@ -624,12 +624,12 @@ class DVM:
if encrypted:
print(content)
if is_legacy_encryption:
content = nip04_encrypt(self.keys.secret_key(), PublicKey.from_hex(original_event.author().to_hex()),
content = nip04_encrypt(self.keys.secret_key(), PublicKey.parse(original_event.author().to_hex()),
content)
else:
content = nip44_encrypt(self.keys.secret_key(),
PublicKey.from_hex(original_event.author().to_hex()),
PublicKey.parse(original_event.author().to_hex()),
content, Nip44Version.V2)
reply_tags = encryption_tags
@ -639,13 +639,19 @@ class DVM:
self.keys)
#print(reply_event)
# send_event(reply_event, client=self.client, dvm_config=self.dvm_config)
await send_event_outbox(reply_event, client=self.client, dvm_config=self.dvm_config)
response_status = await send_event_outbox(reply_event, client=self.client, dvm_config=self.dvm_config)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print(bcolors.GREEN + "[" + self.dvm_config.NIP89.NAME + "] " + str(
original_event.kind().as_u16() + 1000) + " Job Response event sent: " + reply_event.as_json() + bcolors.ENDC)
original_event.kind().as_u16() + 1000) + " Job Response event sent: " + reply_event.as_json() + ". Success: " + str(
response_status.success) + " Failed: " + str(response_status.failed) + " EventID: "
+ response_status.id.to_hex() + " / " + response_status.id.to_bech32() + bcolors.ENDC)
elif self.dvm_config.LOGLEVEL.value >= LogLevel.INFO.value:
print(bcolors.GREEN + "[" + self.dvm_config.NIP89.NAME + "] " + str(
original_event.kind().as_u16() + 1000) + " Job Response event sent: " + reply_event.id().to_hex() + bcolors.ENDC)
original_event.kind().as_u16() + 1000) + " Job Response event sent. Success: " + str(
response_status.success) + " Failed: " + str(response_status.failed) + " EventID: "
+ response_status.id.to_hex() + " / " + response_status.id.to_bech32() + bcolors.ENDC)
async def send_job_status_reaction(original_event, status, is_paid=True, amount=0, client=None,
content=None,
@ -751,11 +757,11 @@ class DVM:
content = json.dumps(str_tags)
if is_legacy_encryption:
content = nip04_encrypt(self.keys.secret_key(), PublicKey.from_hex(original_event.author().to_hex()),
content = nip04_encrypt(self.keys.secret_key(), PublicKey.parse(original_event.author().to_hex()),
content)
else:
content = nip44_encrypt(self.keys.secret_key(),
PublicKey.from_hex(original_event.author().to_hex()),
PublicKey.parse(original_event.author().to_hex()),
content, version=Nip44Version.V2)
reply_tags = encryption_tags
@ -768,14 +774,19 @@ class DVM:
keys = Keys.parse(dvm_config.PRIVATE_KEY)
reaction_event = EventBuilder(EventDefinitions.KIND_FEEDBACK, str(content)).tags(reply_tags).sign_with_keys(keys)
# send_event(reaction_event, client=self.client, dvm_config=self.dvm_config)
await send_event_outbox(reaction_event, client=self.client, dvm_config=self.dvm_config)
response_status = await send_event_outbox(reaction_event, client=self.client, dvm_config=self.dvm_config)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print(bcolors.YELLOW + "[" + self.dvm_config.NIP89.NAME + "]" + " Sent Kind " + str(
EventDefinitions.KIND_FEEDBACK.as_u16()) + " Reaction: " + status + " " + reaction_event.as_json() + bcolors.ENDC)
print(bcolors.YELLOW + "[" + self.dvm_config.NIP89.NAME + "] Sent Kind " + str(
EventDefinitions.KIND_FEEDBACK.as_u16()) + " Reaction: " + status + " " + reaction_event.as_json() + ". Success: " + str(
response_status.success) + " Failed: " + str(response_status.failed) + " EventID: "
+ response_status.id.to_hex() + " / " + response_status.id.to_bech32() + bcolors.ENDC)
elif self.dvm_config.LOGLEVEL.value >= LogLevel.INFO.value:
print(bcolors.YELLOW + "[" + self.dvm_config.NIP89.NAME + "]" + " Sent Kind " + str(
EventDefinitions.KIND_FEEDBACK.as_u16()) + " Reaction: " + status + " " + reaction_event.id().to_hex() + bcolors.ENDC)
print(bcolors.YELLOW + "[" + self.dvm_config.NIP89.NAME + "] Sent Kind " + str(
EventDefinitions.KIND_FEEDBACK.as_u16()) + " Reaction: " + status + ". Success: " + str(
response_status.success) + " Failed: " + str(response_status.failed) + " EventID: "
+ response_status.id.to_hex() + " / " + response_status.id.to_bech32() + bcolors.ENDC)
return reaction_event.as_json()

2
nostr_dvm/subscription.py
View File

@ -147,7 +147,7 @@ class Subscription:
str_tags.append(element.as_vec())
content = json.dumps(str_tags)
content = nip44_encrypt(self.keys.secret_key(), PublicKey.from_hex(original_event.author().to_hex()),
content = nip44_encrypt(self.keys.secret_key(), PublicKey.parse(original_event.author().to_hex()),
content, Nip44Version.V2)
reply_tags = encryption_tags

9
nostr_dvm/tasks/advanced_search.py
View File

@ -87,7 +87,7 @@ class AdvancedSearch(DVMTaskInterface):
from nostr_sdk import Filter
options = self.set_options(request_form)
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
cli = Client(NostrSigner.keys(keys))
@ -110,12 +110,7 @@ class AdvancedSearch(DVMTaskInterface):
user = tag.as_vec()[1]
# user = user[1]
user = str(user).lstrip("@")
if str(user).startswith('npub'):
userkey = PublicKey.from_bech32(user)
elif str(user).startswith("nostr:npub"):
userkey = PublicKey.from_nostr_uri(user)
else:
userkey = PublicKey.from_hex(user)
userkey = PublicKey.parse(user)
userkeys.append(userkey)

7
nostr_dvm/tasks/advanced_search_wine.py
View File

@ -89,12 +89,7 @@ class AdvancedSearchWine(DVMTaskInterface):
tag = Tag.parse(user)
user = tag.as_vec()[1]
user = str(user).lstrip("@")
if str(user).startswith('npub'):
userkey = PublicKey.from_bech32(user)
elif str(user).startswith("nostr:npub"):
userkey = PublicKey.from_nostr_uri(user)
else:
userkey = PublicKey.from_hex(user)
userkey = PublicKey.parse(user)
userkeys.append(userkey)

4
nostr_dvm/tasks/content_discovery_currently_latest_longform.py
View File

@ -107,7 +107,7 @@ class DicoverContentLatestLongForm(DVMTaskInterface):
options = self.set_options(request_form)
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
@ -172,7 +172,7 @@ class DicoverContentLatestLongForm(DVMTaskInterface):
try:
relaylimits = RelayLimits.disable()
opts = (Options().relay_limits(relaylimits))
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).opts(opts).build()

4
nostr_dvm/tasks/content_discovery_currently_latest_wiki.py
View File

@ -107,7 +107,7 @@ class DicoverContentLatestWiki(DVMTaskInterface):
options = self.set_options(request_form)
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
@ -172,7 +172,7 @@ class DicoverContentLatestWiki(DVMTaskInterface):
try:
relaylimits = RelayLimits.disable()
opts = (Options().relay_limits(relaylimits))
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).opts(opts).build()

2
nostr_dvm/tasks/content_discovery_currently_popular.py
View File

@ -170,7 +170,7 @@ class DicoverContentCurrentlyPopular(DVMTaskInterface):
async def sync_db(self):
try:
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)

2
nostr_dvm/tasks/content_discovery_currently_popular_by_top_zaps.py
View File

@ -213,7 +213,7 @@ class DicoverContentCurrentlyPopularZaps(DVMTaskInterface):
async def sync_db(self):
try:
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

4
nostr_dvm/tasks/content_discovery_currently_popular_followers.py
View File

@ -94,7 +94,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
opts = (
Options().relay_limits(
relaylimits))
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
@ -189,7 +189,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
async def sync_db(self):
try:
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

4
nostr_dvm/tasks/content_discovery_currently_popular_gallery.py
View File

@ -133,7 +133,7 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
relaylimits = RelayLimits.disable()
opts = (Options().relay_limits(relaylimits))
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
cli = ClientBuilder().database(databasegallery).signer(NostrSigner.keys(keys)).opts(opts).build()
@ -233,7 +233,7 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
async def sync_db(self):
try:
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

2
nostr_dvm/tasks/content_discovery_currently_popular_mostr.py
View File

@ -176,7 +176,7 @@ class DicoverContentCurrentlyPopularMostr(DVMTaskInterface):
async def sync_db(self):
try:
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

4
nostr_dvm/tasks/content_discovery_currently_popular_nonfollowers.py
View File

@ -142,7 +142,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
relaylimits = RelayLimits.disable()
opts = (
Options().relay_limits(relaylimits))
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
if self.database is None:
self.database = NostrDatabase.lmdb(self.db_name)
@ -225,7 +225,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
async def sync_db(self):
try:
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

2
nostr_dvm/tasks/content_discovery_currently_popular_topic.py
View File

@ -202,7 +202,7 @@ class DicoverContentCurrentlyPopularbyTopic(DVMTaskInterface):
async def sync_db(self):
try:
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

2
nostr_dvm/tasks/content_discovery_currently_popular_tweets.py
View File

@ -191,7 +191,7 @@ class DicoverContentCurrentlyPopularTweets(DVMTaskInterface):
async def sync_db(self):
try:
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

2
nostr_dvm/tasks/content_discovery_latest_one_per_follower.py
View File

@ -69,7 +69,7 @@ class Discoverlatestperfollower(DVMTaskInterface):
from types import SimpleNamespace
ns = SimpleNamespace()
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
relaylimits = RelayLimits.disable()

2
nostr_dvm/tasks/content_discovery_on_this_day.py
View File

@ -175,7 +175,7 @@ class DicoverContentOnThisDay(DVMTaskInterface):
async def sync_db(self):
try:
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)

2
nostr_dvm/tasks/content_discovery_update_db_only.py
View File

@ -137,7 +137,7 @@ class DicoverContentDBUpdateScheduler(DVMTaskInterface):
opts = (Options().relay_limits(relaylimits))
if self.dvm_config.WOT_FILTERING:
opts = opts.filtering_mode(RelayFilteringMode.WHITELIST)
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
if self.database is None:
self.database = await init_db(self.db_name, True, self.max_db_size)

4
nostr_dvm/tasks/discovery_bot_farms.py
View File

@ -74,7 +74,7 @@ class DiscoveryBotFarms(DVMTaskInterface):
from nostr_sdk import Filter
options = self.set_options(request_form)
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb("db/nostr_profiles.db")
@ -134,7 +134,7 @@ class DiscoveryBotFarms(DVMTaskInterface):
return 1
async def sync_db(self):
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb("db/nostr_profiles.db")
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

2
nostr_dvm/tasks/discovery_censor_wot.py
View File

@ -71,7 +71,7 @@ class DiscoverReports(DVMTaskInterface):
relaylimits = RelayLimits.disable()
opts = (
Options().relay_limits(relaylimits))
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
cli = ClientBuilder().signer(NostrSigner.keys(keys)).opts(opts).build()
# cli.add_relay("wss://relay.nostr.band")

4
nostr_dvm/tasks/discovery_inactive_follows.py
View File

@ -68,7 +68,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
from types import SimpleNamespace
ns = SimpleNamespace()
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
# relaylimits = RelayLimits().event_max_num_tags(max_num_tags=10000)
# relaylimits.event_max_size(None)
@ -130,7 +130,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
filters = []
for i in range(i, i + st):
filter1 = Filter().author(PublicKey.from_hex(users[i])).since(notactivesince).limit(1)
filter1 = Filter().author(PublicKey.parse(users[i])).since(notactivesince).limit(1)
filters.append(filter1)
event_from_authors = await cli.fetch_events(filters, relay_timeout_long)
for author in event_from_authors.to_vec():

6
nostr_dvm/tasks/discovery_nonfollowers.py
View File

@ -66,7 +66,7 @@ class DiscoverNonFollowers(DVMTaskInterface):
opts = (
Options().relay_limits(
relaylimits))
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
cli= ClientBuilder().signer(NostrSigner.keys(keys)).opts(opts).build()
@ -81,7 +81,7 @@ class DiscoverNonFollowers(DVMTaskInterface):
options = self.set_options(request_form)
step = 20
followers_filter = Filter().author(PublicKey.from_hex(options["user"])).kind(Kind(3))
followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
followers = await cli.fetch_events([followers_filter], relay_timeout)
if len(followers.to_vec()) > 0:
@ -113,7 +113,7 @@ class DiscoverNonFollowers(DVMTaskInterface):
for i in range(i, i + st):
filters = []
filter1 = Filter().author(PublicKey.from_hex(users[i])).kind(Kind(3))
filter1 = Filter().author(PublicKey.parse(users[i])).kind(Kind(3))
filters.append(filter1)
followers = await cli.fetch_events(filters, relay_timeout)

2
nostr_dvm/tasks/discovery_trending_notes_gleasonator.py
View File

@ -70,7 +70,7 @@ class TrendingNotesGleasonator(DVMTaskInterface):
async def process(self, request_form):
options = self.set_options(request_form)
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
cli = Client(NostrSigner.keys(keys))

2
nostr_dvm/tasks/people_discovery_mywot.py
View File

@ -203,7 +203,7 @@ class DiscoverPeopleMyWOT(DVMTaskInterface):
async def sync_db(self):
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

2
nostr_dvm/tasks/people_discovery_wot.py
View File

@ -207,7 +207,7 @@ class DiscoverPeopleWOT(DVMTaskInterface):
return 1
async def sync_db(self):
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().signer(NostrSigner.keys(keys)).database(database).build()

4
nostr_dvm/tasks/search_users.py
View File

@ -79,7 +79,7 @@ class SearchUser(DVMTaskInterface):
from nostr_sdk import Filter
options = self.set_options(request_form)
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
cli = ClientBuilder().database(database).signer(NostrSigner.keys(keys)).build()
@ -140,7 +140,7 @@ class SearchUser(DVMTaskInterface):
return 1
async def sync_db(self):
sk = SecretKey.from_hex(self.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(self.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
database = NostrDatabase.lmdb(self.db_name)
relaylimits = RelayLimits.disable()

6
nostr_dvm/utils/admin_utils.py
View File

@ -9,7 +9,7 @@ from nostr_dvm.utils.nip65_utils import nip65_announce_relays
from nostr_dvm.utils.nip88_utils import nip88_announce_tier, fetch_nip88_parameters_for_deletion, fetch_nip88_event, \
check_and_set_tiereventid_nip88
from nostr_dvm.utils.nip89_utils import nip89_announce_tasks, fetch_nip89_parameters_for_deletion
from nostr_dvm.utils.nostr_utils import update_profile
from nostr_dvm.utils.nostr_utils import update_profile, print_send_result
from nostr_dvm.utils.nut_wallet_utils import NutZapWallet
@ -128,5 +128,5 @@ async def admin_make_database_updates(adminconfig: AdminConfig = None, dvmconfig
await fetch_nip88_event(keys, event_id, client, dvmconfig)
if adminconfig.UPDATE_PROFILE:
event = await update_profile(dvmconfig, client, lud16=dvmconfig.LN_ADDRESS)
print(event.output)
event_result = await update_profile(dvmconfig, client, lud16=dvmconfig.LN_ADDRESS)
print_send_result(event_result)

2
nostr_dvm/utils/external_dvm_utils.py
View File

@ -22,7 +22,7 @@ async def build_client(config):
def build_external_dvm(pubkey, task, kind, fix_cost, per_unit_cost, config,
external_post_process=PostProcessFunctionType.NONE):
pubkey = PublicKey.from_hex(pubkey).to_hex()
pubkey = PublicKey.parse(pubkey).to_hex()
dvm_config = DVMConfig()
dvm_config.PUBLIC_KEY = pubkey
dvm_config.FIX_COST = fix_cost

7
nostr_dvm/utils/gallery_utils.py
View File

@ -16,7 +16,7 @@ import requests
from urllib.parse import urlparse
from nostr_dvm.utils.nostr_utils import send_event
from nostr_dvm.utils.nostr_utils import send_event, print_send_result
from nostr_dvm.utils.print_utils import bcolors
@ -88,8 +88,9 @@ async def convert_nip93_to_nip68(private_key, relay_list, user_to_import_npub=No
var = input("Convert and post this image? (y(es)/n(o)/d(elete): " + image_url + " Content: " + content + "\n")
if var == "d" or var == "delete":
delete_event = EventBuilder.delete([event.id()]).sign_with_keys(keys)
result = await client.send_event(delete_event)
print(result.output)
response_status = await client.send_event(delete_event)
print_send_result(response_status)
elif var == "y" or var == "yes":

18
nostr_dvm/utils/nip65_utils.py
View File

@ -16,11 +16,12 @@ async def announce_dm_relays(dvm_config, client):
content = ""
event = EventBuilder(Kind(10050), content).tags(tags).sign_with_keys(keys)
eventid = await send_event(event, client=client, dvm_config=dvm_config, broadcast=True)
if eventid is not None:
response_status = await send_event(event, client=client, dvm_config=dvm_config, broadcast=True)
if response_status is not None:
print(
bcolors.BLUE + "[" + dvm_config.NIP89.NAME + "] Announced DM relays for " + dvm_config.NIP89.NAME + " (EventID: " + str(
eventid.id.to_hex()) + ")" + bcolors.ENDC)
bcolors.BLUE + "[" + dvm_config.NIP89.NAME + "] Announced DM relays for " + dvm_config.NIP89.NAME + ". Success: " + str(
response_status.success) + " Failed: " + str(response_status.failed) + " EventID: "
+ response_status.id.to_hex() + " / " + response_status.id.to_bech32())
else:
print(
bcolors.RED + "[" + dvm_config.NIP89.NAME + "] Could not announce DM relays for " + dvm_config.NIP89.NAME + bcolors.ENDC)
@ -40,11 +41,12 @@ async def nip65_announce_relays(dvm_config, client):
content = ""
event = EventBuilder(EventDefinitions.KIND_RELAY_ANNOUNCEMENT, content).tags(tags).sign_with_keys(keys)
eventid = await send_event(event, client=client, dvm_config=dvm_config, broadcast=True)
if eventid is not None:
response_status = await send_event(event, client=client, dvm_config=dvm_config, broadcast=True)
if response_status is not None:
print(
bcolors.BLUE + "[" + dvm_config.NIP89.NAME + "] Announced NIP 65 for " + dvm_config.NIP89.NAME + " (EventID: " + str(
eventid.id.to_hex()) + ")" + bcolors.ENDC)
bcolors.BLUE + "[" + dvm_config.NIP89.NAME + "] Announced NIP 65 for " + dvm_config.NIP89.NAME + ". Success: " + str(
response_status.success) + " Failed: " + str(response_status.failed) + " EventID: "
+ response_status.id.to_hex() + " / " + response_status.id.to_bech32())
else:
print(
bcolors.RED + "[" + dvm_config.NIP89.NAME + "] Could not announce NIP 65 for " + dvm_config.NIP89.NAME + bcolors.ENDC)

2
nostr_dvm/utils/nip88_utils.py
View File

@ -35,7 +35,7 @@ def nip88_create_d_tag(name, pubkey, image):
async def fetch_nip88_parameters_for_deletion(keys, eventid, client, dvmconfig):
idfilter = Filter().id(EventId.from_hex(eventid)).limit(1)
idfilter = Filter().id(EventId.parse(eventid)).limit(1)
nip88events = await client.fetch_events([idfilter], relay_timeout)
d_tag = ""
if len(nip88events.to_vec()) == 0:

27
nostr_dvm/utils/nip89_utils.py
View File

@ -6,7 +6,7 @@ import dotenv
from nostr_sdk import Tag, Keys, EventBuilder, Filter, Alphabet, PublicKey, Client, EventId, SingleLetterTag, Kind
from nostr_dvm.utils.definitions import EventDefinitions, relay_timeout
from nostr_dvm.utils.nostr_utils import send_event
from nostr_dvm.utils.nostr_utils import send_event, print_send_result
from nostr_dvm.utils.print_utils import bcolors
@ -31,15 +31,15 @@ async def nip89_announce_tasks(dvm_config, client):
content = dvm_config.NIP89.CONTENT
event = EventBuilder(EventDefinitions.KIND_ANNOUNCEMENT, content).tags([k_tag, d_tag]).sign_with_keys(keys)
eventid = await send_event(event, client=client, dvm_config=dvm_config, broadcast=True)
print(eventid.output)
response_status = await send_event(event, client=client, dvm_config=dvm_config, broadcast=True)
print(
bcolors.BLUE + "[" + dvm_config.NIP89.NAME + "] Announced NIP 89 for " + dvm_config.NIP89.NAME + " (" + eventid.id.to_hex() + ")" + bcolors.ENDC)
print(bcolors.BLUE + "[" + dvm_config.NIP89.NAME + "] Announced NIP 89 for " + dvm_config.NIP89.NAME + ". Success: " + str(response_status.success) + " Failed: " + str(response_status.failed) + " EventID: "
+ response_status.id.to_hex() + " / " + response_status.id.to_bech32())
async def fetch_nip89_parameters_for_deletion(keys, eventid, client, dvmconfig, pow=False):
idfilter = Filter().id(EventId.from_hex(eventid)).limit(1)
idfilter = Filter().id(EventId.parse(eventid)).limit(1)
nip89events = await client.fetch_events([idfilter], relay_timeout)
d_tag = ""
if len(nip89events.to_vec()) == 0:
@ -73,13 +73,8 @@ async def nip89_delete_announcement(eid: str, keys: Keys, dtag: str, client: Cli
event = EventBuilder(Kind(5), "").tags([e_tag, a_tag]).sign_with_keys(keys)
print(f"Deletion event: {event.as_json()}")
new_dvm_config = DVMConfig()
new_dvm_config.RELAY_LIST = new_dvm_config.ANNOUNCE_RELAY_LIST
for relay in config.RELAY_LIST:
if relay not in new_dvm_config.RELAY_LIST:
new_dvm_config.RELAY_LIST.append(relay)
await send_event(event, client, new_dvm_config)
await send_event(event, client, config, broadcast=True)
async def nip89_delete_announcement_pow(eid: str, keys: Keys, dtag: str, client: Client, config):
@ -88,13 +83,7 @@ async def nip89_delete_announcement_pow(eid: str, keys: Keys, dtag: str, client:
["a", str(EventDefinitions.KIND_ANNOUNCEMENT.as_u16()) + ":" + keys.public_key().to_hex() + ":" + dtag])
event = EventBuilder(Kind(5), "").tags([e_tag, a_tag]).pow(28).sign_with_keys(keys)
print(f"POW event: {event.as_json()}")
new_dvm_config = DVMConfig()
new_dvm_config.RELAY_LIST = new_dvm_config.ANNOUNCE_RELAY_LIST
for relay in config.RELAY_LIST:
if relay not in new_dvm_config.RELAY_LIST:
new_dvm_config.RELAY_LIST.append(relay)
await send_event(event, client, new_dvm_config)
await send_event(event, client, config, broadcast=True)
async def nip89_fetch_all_dvms(client):

58
nostr_dvm/utils/nostr_utils.py
View File

@ -15,7 +15,7 @@ from nostr_dvm.utils.definitions import EventDefinitions, relay_timeout
async def get_event_by_id(event_id_str: str, client: Client, config=None) -> Event | None:
split = event_id_str.split(":")
if len(split) == 3:
pk = PublicKey.from_hex(split[1])
pk = PublicKey.parse(split[1])
id_filter = Filter().author(pk).custom_tag(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
events = await client.fetch_events([id_filter], relay_timeout)
else:
@ -43,21 +43,17 @@ async def get_events_by_ids(event_ids, client: Client, config=None) -> List | No
for event_id in event_ids:
split = event_id.split(":")
if len(split) == 3:
pk = PublicKey.from_hex(split[1])
pk = PublicKey.parse(split[1])
id_filter = Filter().author(pk).custom_tag(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
events = await client.fetch_events([id_filter], relay_timeout)
else:
if str(event_id).startswith('note'):
event_id = EventId.from_bech32(event_id)
elif str(event_id).startswith("nevent"):
if str(event_id).startswith("nevent"):
event_id = Nip19Event.from_bech32(event_id).event_id()
elif str(event_id).startswith('nostr:note'):
event_id = EventId.from_nostr_uri(event_id)
elif str(event_id).startswith("nostr:nevent"):
event_id = Nip19Event.from_nostr_uri(event_id).event_id()
else:
event_id = EventId.from_hex(event_id)
event_id = EventId.parse(event_id)
search_ids.append(event_id)
id_filter = Filter().ids(search_ids)
@ -82,16 +78,12 @@ async def get_events_by_id(event_ids: list, client: Client, config=None) -> list
async def get_referenced_event_by_id(event_id, client, dvm_config, kinds) -> Event | None:
if kinds is None:
kinds = []
if str(event_id).startswith('note'):
event_id = EventId.from_bech32(event_id)
elif str(event_id).startswith("nevent"):
if str(event_id).startswith("nevent"):
event_id = Nip19Event.from_bech32(event_id).event_id()
elif str(event_id).startswith('nostr:note'):
event_id = EventId.from_nostr_uri(event_id)
elif str(event_id).startswith("nostr:nevent"):
event_id = Nip19Event.from_nostr_uri(event_id).event_id()
else:
event_id = EventId.from_hex(event_id)
event_id = EventId.parse(event_id)
if len(kinds) > 0:
job_id_filter = Filter().kinds(kinds).event(event_id).limit(1)
@ -219,10 +211,10 @@ async def send_event_outbox(event: Event, client, dvm_config) -> SendEventOutput
# connection = Connection().addr("127.0.0.1:9050").target(ConnectionTarget.ONION)
opts = Options().relay_limits(relaylimits).connection(connection)
sk = SecretKey.from_hex(dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
outboxclient = ClientBuilder().signer(NostrSigner.keys(keys)).opts(opts).build()
print("[" + dvm_config.NIP89.NAME + "] Receiver Inbox relays: " + str(relays))
#print("[" + dvm_config.NIP89.NAME + "] Receiver Inbox relays: " + str(relays))
for relay in relays[:5]:
try:
@ -233,14 +225,14 @@ async def send_event_outbox(event: Event, client, dvm_config) -> SendEventOutput
await outboxclient.connect()
try:
#print("Connected, sending event")
event_id = await outboxclient.send_event(event)
print(event_id.output)
event_response = await outboxclient.send_event(event)
except Exception as e:
event_id = None
event_response = None
print(e)
# 5. Fallback, if we couldn't send the event to any relay, we try to send to generic relays instead.
if event_id is None:
if event_response is None:
relays = await get_main_relays(event, client, dvm_config)
if len(relays) == 0:
return None
@ -248,15 +240,16 @@ async def send_event_outbox(event: Event, client, dvm_config) -> SendEventOutput
await outboxclient.add_relay(relay)
try:
await outboxclient.connect()
event_id = await outboxclient.send_event(event)
event_response = await outboxclient.send_event(event)
except Exception as e:
# Love yourself then.
event_id = None
event_response = None
print(e)
await outboxclient.shutdown()
return event_id
return event_response
async def send_event(event: Event, client: Client, dvm_config, broadcast=False):
@ -280,7 +273,7 @@ async def send_event(event: Event, client: Client, dvm_config, broadcast=False):
if len(relays) == 0:
relays = relay_list
print(relays)
for relay in relays:
if relay not in dvm_config.RELAY_LIST:
await client.add_relay(relay)
@ -288,19 +281,24 @@ async def send_event(event: Event, client: Client, dvm_config, broadcast=False):
await client.connect()
try:
event_id = await client.send_event(event)
response_status = await client.send_event(event)
except Exception as e:
print(e)
event_id = None
response_status = None
for relay in relays:
if relay not in dvm_config.RELAY_LIST:
await client.force_remove_relay(relay)
return event_id
return response_status
except Exception as e:
print(e)
def print_send_result(response_status):
print("Success: " + str(response_status.success) + " Failed: " + str(response_status.failed) + " EventID: "
+ response_status.id.to_hex() + " / " + response_status.id.to_bech32())
def check_and_decrypt_tags(event, dvm_config):
is_encrypted = False
use_legacy_encryption = False
@ -364,10 +362,10 @@ def check_and_decrypt_own_tags(event, dvm_config):
elif event.author().to_hex() == dvm_config.PUBLIC_KEY:
try:
tags_str = nip44_decrypt(Keys.parse(dvm_config.PRIVATE_KEY).secret_key(),
PublicKey.from_hex(p), event.content())
PublicKey.parse(p), event.content())
except:
tags_str = nip04_decrypt(Keys.parse(dvm_config.PRIVATE_KEY).secret_key(),
PublicKey.from_hex(p), event.content())
PublicKey.parse(p), event.content())
params = json.loads(tags_str)
params.append(Tag.parse(["p", p]).as_vec())
params.append(Tag.parse(["encrypted"]).as_vec())

2
nostr_dvm/utils/output_utils.py
View File

@ -107,7 +107,7 @@ def post_process_list_to_events(result):
for tag in result_list:
try:
e_tag = Tag.parse(tag)
id = EventId.from_hex(e_tag.as_vec()[1]).to_bech32()
id = EventId.parse(e_tag.as_vec()[1]).to_bech32()
result_str = result_str + "nostr:" + id + "\n"
except Exception as e:
print(e)

4
setup.py
View File

@ -1,6 +1,6 @@
from setuptools import setup, find_packages
VERSION = '1.0.5'
VERSION = '1.0.6'
DESCRIPTION = 'A framework to build and run Nostr NIP90 Data Vending Machines'
LONG_DESCRIPTION = ('A framework to build and run Nostr NIP90 Data Vending Machines. See the github repository for more information')
@ -14,7 +14,7 @@ setup(
long_description=LONG_DESCRIPTION,
packages=find_packages(include=['nostr_dvm', 'nostr_dvm.*']),
install_requires=["nostr-sdk==0.37.0",
install_requires=["nostr-sdk==0.38.0",
"bech32==1.2.0",
"pycryptodome==3.20.0",
"yt-dlp==2024.11.04",

2
tests/generic_dvm_autotopic_feed.py
View File

@ -120,7 +120,7 @@ def playground(announce=False):
async def process(request_form):
since = 2 * 60 * 60
options = dvm.set_options(request_form)
sk = SecretKey.from_hex(dvm.dvm_config.PRIVATE_KEY)
sk = SecretKey.parse(dvm.dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())
relaylimits = RelayLimits.disable()

4
tests/test_dvm_client.py
View File

@ -326,7 +326,7 @@ async def nostr_client_test_discovery_user(user, ptag):
await client.add_relay(relay)
await client.connect()
config = DVMConfig
eventid = await send_event(event, client=client, dvm_config=config)
await send_event(event, client=client, dvm_config=config)
return event.as_json()
@ -351,7 +351,7 @@ async def nostr_client_test_discovery_gallery(user, ptag):
await client.add_relay(relay)
await client.connect()
config = DVMConfig
eventid = await send_event(event, client=client, dvm_config=config)
await send_event(event, client=client, dvm_config=config)
return event.as_json()

8
tests/test_events.py
View File

@ -28,14 +28,14 @@ async def test():
await test_referred_events(client, "5635e5dd930b3c831f6ab1e348bb488f3c9aca2f13190e93ab5e5e1e1ba1835e",
definitions.EventDefinitions.ANY_RESULT)
bech32evnt = EventId.from_hex("5635e5dd930b3c831f6ab1e348bb488f3c9aca2f13190e93ab5e5e1e1ba1835e").to_bech32()
bech32evnt = EventId.parse("5635e5dd930b3c831f6ab1e348bb488f3c9aca2f13190e93ab5e5e1e1ba1835e").to_bech32()
print(bech32evnt)
test = Nip19Event.from_bech32(
"nevent1qqsrjcpejsrlt3u7dy42y6rc97svrq9ver08xy4jr2ll55ynq3sxafcppamhxue69uhkummnw3ezumt0d5pzpmnqx2pla0zvxxcfjqeeysy29ll3mtmf4s3yff0y45r7egau080vqvzqqqqqqyu4q839")
print(test.event_id().to_hex())
nostruri = EventId.from_hex("5635e5dd930b3c831f6ab1e348bb488f3c9aca2f13190e93ab5e5e1e1ba1835e").to_nostr_uri()
nostruri = EventId.parse("5635e5dd930b3c831f6ab1e348bb488f3c9aca2f13190e93ab5e5e1e1ba1835e").to_nostr_uri()
print(nostruri)
await test_search_by_user_since_days(client,
@ -49,9 +49,9 @@ async def test_referred_events(client, event_id, kinds=None):
kinds = []
if len(kinds) > 0:
job_id_filter = Filter().kinds(kinds).event(EventId.from_hex(event_id))
job_id_filter = Filter().kinds(kinds).event(EventId.parse(event_id))
else:
job_id_filter = Filter().event(EventId.from_hex(event_id))
job_id_filter = Filter().event(EventId.parse(event_id))
event_struct = await client.fetch_events([job_id_filter], relay_timeout)
events = event_struct.to_vec()

6
tutorials/03_client.py
View File

@ -11,7 +11,7 @@ from nostr_dvm.utils.print_utils import bcolors
import dotenv
from nostr_sdk import Keys, Client, Tag, EventBuilder, Filter, HandleNotification, Timestamp, nip04_decrypt, \
NostrSigner, Event, Kind, PublicKey
from nostr_dvm.utils.nostr_utils import send_event, check_and_set_private_key
from nostr_dvm.utils.nostr_utils import send_event, check_and_set_private_key, print_send_result
from nostr_dvm.utils.definitions import EventDefinitions
@ -46,8 +46,8 @@ async def nostr_client_generic_test(ptag):
# We connect the client
await client.connect()
# and send the Event.
result = await send_event(event, client=client, dvm_config=DVMConfig())
print(result)
response_status = await send_event(event, client=client, dvm_config=DVMConfig())
print_send_result(response_status)
async def nostr_client(target_dvm_npub):

6
tutorials/09_nutzap_client.py
View File

@ -14,7 +14,7 @@ from nostr_sdk import PublicKey, Client, NostrSigner, EventBuilder, Kind, Tag, K
import asyncio
from nostr_dvm.utils.definitions import EventDefinitions
from nostr_dvm.utils.dvmconfig import DVMConfig
from nostr_dvm.utils.nostr_utils import send_event, check_and_set_private_key
from nostr_dvm.utils.nostr_utils import send_event, check_and_set_private_key, print_send_result
from nostr_dvm.utils.nut_wallet_utils import NutZapWallet
from nostr_dvm.utils.print_utils import bcolors
@ -36,8 +36,8 @@ async def nostr_client_generic_test(ptag):
for relay in relay_list:
await client.add_relay(relay)
await client.connect()
result = await send_event(event, client=client, dvm_config=DVMConfig())
print(result)
response_status = await send_event(event, client=client, dvm_config=DVMConfig())
print_send_result(response_status)
async def nostr_client(target_dvm_npub):