highperfocused/nostrdvm
1
0
Fork 0
mirror of https://github.com/believethehype/nostrdvm.git synced 2025-03-17 13:21:48 +01:00
Code Issues Packages Projects Releases Wiki Activity

adjustments for nostrsdk 0.39

Browse Source
This commit is contained in:
dbth 2025-02-01 19:35:39 +01:00
parent 86d96a4772
commit f9b68d3b6d
49 changed files with 183 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -199,3 +199,4 @@ tests/cat4.png
tests/gifs/data.mdb
tests/gifs/lock.mdb
tests/gif_library.py
/.idea

3
examples/ollama_dvm/test_client.py
View File

@ -51,7 +51,8 @@ async def nostr_client():
Timestamp.now()) # events to us specific
dvm_filter = (Filter().kinds([EventDefinitions.KIND_NIP90_RESULT_GENERATE_TEXT,
EventDefinitions.KIND_FEEDBACK]).since(Timestamp.now())) # public events
await client.subscribe([dm_zap_filter, dvm_filter])
await client.subscribe(dm_zap_filter)
await client.subscribe(dvm_filter)
await nostr_client_test_llm("Tell me a joke about a purple Ostrich!")

3
examples/tts_dvm/test_client.py
View File

@ -56,7 +56,8 @@ async def nostr_client():
Timestamp.now()) # events to us specific
dvm_filter = (Filter().kinds([EventDefinitions.KIND_NIP90_RESULT_TEXT_TO_SPEECH,
EventDefinitions.KIND_FEEDBACK]).since(Timestamp.now())) # public events
await client.subscribe([dm_zap_filter, dvm_filter])
await client.subscribe(dm_zap_filter)
await client.subscribe(dvm_filter)
await nostr_client_test_tts("Hello, this is a test. Mic check one, two.")

3
examples/unleashed_dvm/test_client.py
View File

@ -54,7 +54,8 @@ async def nostr_client():
Timestamp.now()) # events to us specific
dvm_filter = (Filter().kinds([EventDefinitions.KIND_NIP90_RESULT_GENERATE_TEXT,
EventDefinitions.KIND_FEEDBACK]).since(Timestamp.now())) # public events
await client.subscribe([dm_zap_filter, dvm_filter])
await client.subscribe(dm_zap_filter)
await client.subscribe(dvm_filter)
#nostr_client_test("What has Pablo been up to?")

25
nostr_dvm/bot.py
View File

@ -2,10 +2,9 @@ import asyncio
import json
import os
import signal
from multiprocessing.connection import Connection
from nostr_sdk import (Keys, Timestamp, Filter, nip04_decrypt, nip44_decrypt, HandleNotification, EventBuilder, PublicKey,
Options, Tag, Event, EventId, Nip19Event, Kind, KindEnum, NostrSigner, nip44_encrypt, Nip44Version,
Options, Tag, Event, EventId, Nip19Event, Kind, NostrSigner, nip44_encrypt, Nip44Version,
UnsignedEvent, UnwrappedGift, uniffi_set_event_loop, ClientBuilder, make_private_msg)
from nostr_dvm.utils.admin_utils import admin_make_database_updates
@ -35,7 +34,7 @@ class Bot:
self.client = None
asyncio.run(self.run_bot(dvm_config, admin_config))
uniffi_set_event_loop(asyncio.get_running_loop())
#uniffi_set_event_loop(asyncio.get_running_loop())
# add_sql_table_column(dvm_config.DB)
@ -74,7 +73,7 @@ class Bot:
zap_filter = Filter().pubkey(pk).kinds([EventDefinitions.KIND_ZAP]).since(Timestamp.now())
dm_filter = Filter().pubkey(pk).kinds([EventDefinitions.KIND_DM]).since(Timestamp.now())
nip17_filter = Filter().pubkey(pk).kinds([Kind.from_enum(KindEnum.GIFT_WRAP())]).limit(0)
nip17_filter = Filter().pubkey(pk).kinds([EventDefinitions.KIND_GIFTWRAP]).limit(0)
kinds = [EventDefinitions.KIND_NIP90_GENERIC, EventDefinitions.KIND_FEEDBACK]
for dvm in self.dvm_config.SUPPORTED_DVMS:
if dvm.KIND not in kinds:
@ -83,7 +82,10 @@ class Bot:
kinds.append(Kind(6050))
dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()))
await self.client.subscribe([zap_filter, dm_filter, nip17_filter, dvm_filter], None)
await self.client.subscribe(zap_filter, None)
await self.client.subscribe(dm_filter, None)
await self.client.subscribe(nip17_filter, None)
await self.client.subscribe(dvm_filter, None)
create_sql_table(self.dvm_config.DB)
await admin_make_database_updates(adminconfig=self.admin_config, dvmconfig=self.dvm_config, client=self.client)
@ -108,7 +110,7 @@ class Bot:
await handle_dm(nostr_event, False)
except Exception as e:
print(f"Error during content NIP04 decryption: {e}")
elif nostr_event.kind().as_enum() == KindEnum.GIFT_WRAP():
elif nostr_event.kind().as_u16() == EventDefinitions.KIND_GIFTWRAP.as_u16():
try:
await handle_dm(nostr_event, True)
except Exception as e:
@ -133,7 +135,7 @@ class Bot:
rumor: UnsignedEvent = unwrapped_gift.rumor()
if rumor.created_at().as_secs() >= Timestamp.now().as_secs():
if rumor.kind().as_enum() == KindEnum.PRIVATE_DIRECT_MESSAGE():
if rumor.kind().as_u16() == EventDefinitions.KIND_PRIVATE_DM.as_u16():
print(f"Received new msg [sealed]: {decrypted_text}")
decrypted_text = rumor.content()
sealed = " [sealed] "
@ -637,7 +639,7 @@ class Bot:
if param == "user":
if value.startswith("@") or value.startswith("nostr:") or value.startswith(
"npub"):
value = PublicKey.from_bech32(
value = PublicKey.parse(
value.replace("@", "").replace("nostr:", "")).to_hex()
tag = Tag.parse(["param", param, value])
tags.append(tag)
@ -718,7 +720,7 @@ class Bot:
else:
if param == "user":
if value.startswith("@") or value.startswith("nostr:") or value.startswith("npub"):
value = PublicKey.from_bech32(
value = PublicKey.parse(
value.replace("@", "").replace("nostr:", "")).to_hex()
tag = Tag.parse(["param", param, value])
tags.append(tag)
@ -766,6 +768,8 @@ class Bot:
return None
asyncio.create_task(self.client.handle_notifications(NotificationHandler()))
try:
@ -793,3 +797,6 @@ class Bot:
except KeyboardInterrupt:
print('Stay weird!')
os.kill(os.getpid(), signal.SIGTERM)

5
nostr_dvm/dvm.py
View File

@ -78,7 +78,8 @@ class DVM:
dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()))
create_sql_table(self.dvm_config.DB)
await admin_make_database_updates(adminconfig=self.admin_config, dvmconfig=self.dvm_config, client=self.client)
await self.client.subscribe([dvm_filter, zap_filter], None)
await self.client.subscribe(dvm_filter, None)
await self.client.subscribe(zap_filter, None)
if self.dvm_config.ENABLE_NUTZAP:
nutzap_wallet = NutZapWallet()
@ -232,7 +233,7 @@ class DVM:
await send_job_status_reaction(nip90_event, "error", False, amount, self.client, cashu_message,
self.dvm_config)
return
# if user is whitelisted or task is free, just do the job
# if user is whitelisted or task is free, just dxo the job
if (user.iswhitelisted or task_is_free or cashu_redeemed) and (
p_tag_str == "" or p_tag_str ==
self.dvm_config.PUBLIC_KEY):

8
nostr_dvm/subscription.py
View File

@ -70,7 +70,9 @@ class Subscription:
[EventDefinitions.KIND_NIP90_DVM_SUBSCRIPTION]).since(
Timestamp.now())
await self.client.subscribe([zap_filter, dvm_filter, cancel_subscription_filter], None)
await self.client.subscribe(zap_filter, None)
await self.client.subscribe(dvm_filter, None)
await self.client.subscribe(cancel_subscription_filter, None)
create_subscription_sql_table(dvm_config.DB)
@ -248,7 +250,7 @@ class Subscription:
subscriptionfilter = Filter().kind(EventDefinitions.KIND_NIP88_SUBSCRIBE_EVENT).author(
PublicKey.parse(subscriber)).limit(1)
evts = await self.client.fetch_events([subscriptionfilter], relay_timeout)
evts = await self.client.fetch_events(subscriptionfilter, relay_timeout)
if len(evts.to_vec()) > 0:
event7001id = evts.to_vec()[0].id().to_hex()
print(evts.to_vec()[0].as_json())
@ -285,7 +287,7 @@ class Subscription:
if tier_dtag == "" or len(zaps) == 0:
tierfilter = Filter().id(EventId.parse(subscription_event_id))
evts = await self.client.fetch_events([tierfilter], relay_timeout)
evts = await self.client.fetch_events(tierfilter, relay_timeout)
if len(evts.to_vec()) > 0:
for tag in evts[0].tags().to_vec():
if tag.as_vec()[0] == "d":

2
nostr_dvm/tasks/advanced_search.py
View File

@ -124,7 +124,7 @@ class AdvancedSearch(DVMTaskInterface):
notes_filter = Filter().kind(Kind(1)).authors(userkeys).search(options["search"]).since(
search_since).until(search_until).limit(options["max_results"])
events = await cli.fetch_events([notes_filter], relay_timeout)
events = await cli.fetch_events(notes_filter, relay_timeout)
result_list = []
if len(events.to_vec()) > 0:

2
nostr_dvm/tasks/content_discovery_currently_latest_longform.py
View File

@ -121,7 +121,7 @@ class DicoverContentLatestLongForm(DVMTaskInterface):
since = Timestamp.from_secs(timestamp_hour_ago)
filter1 = Filter().kind(definitions.EventDefinitions.KIND_LONGFORM).since(since)
events = await cli.database().query([filter1])
events = await cli.database().query(filter1)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
ns.finallist = {}

2
nostr_dvm/tasks/content_discovery_currently_latest_wiki.py
View File

@ -121,7 +121,7 @@ class DicoverContentLatestWiki(DVMTaskInterface):
since = Timestamp.from_secs(timestamp_hour_ago)
filter1 = Filter().kind(definitions.EventDefinitions.KIND_WIKI).since(since)
events = await cli.database().query([filter1])
events = await cli.database().query(filter1)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
ns.finallist = {}

4
nostr_dvm/tasks/content_discovery_currently_popular.py
View File

@ -116,7 +116,7 @@ class DicoverContentCurrentlyPopular(DVMTaskInterface):
filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
events = await database.query([filter1])
events = await database.query(filter1)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
ns.finallist = {}
@ -125,7 +125,7 @@ class DicoverContentCurrentlyPopular(DVMTaskInterface):
filt = Filter().kinds([definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REPOST,
definitions.EventDefinitions.KIND_REACTION,
definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
reactions = await database.query([filt])
reactions = await database.query(filt)
if len(reactions.to_vec()) >= self.min_reactions:
ns.finallist[event.id().to_hex()] = len(reactions.to_vec())

4
nostr_dvm/tasks/content_discovery_currently_popular_by_top_zaps.py
View File

@ -113,7 +113,7 @@ class DicoverContentCurrentlyPopularZaps(DVMTaskInterface):
since = Timestamp.from_secs(timestamp_hour_ago)
filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
events = await database.query([filter1])
events = await database.query(filter1)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
@ -121,7 +121,7 @@ class DicoverContentCurrentlyPopularZaps(DVMTaskInterface):
for event in events.to_vec():
if event.created_at().as_secs() > timestamp_hour_ago:
filt = Filter().kinds([definitions.EventDefinitions.KIND_ZAP]).event(event.id()).since(since)
zaps = await database.query([filt])
zaps = await database.query(filt)
invoice_amount = 0
event_author = event.author().to_hex()
if len(zaps.to_vec()) >= self.min_reactions:

6
nostr_dvm/tasks/content_discovery_currently_popular_followers.py
View File

@ -109,7 +109,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
user = PublicKey.parse(options["user"])
followers_filter = Filter().author(user).kinds([Kind(3)])
followers = await cli.fetch_events([followers_filter], relay_timeout)
followers = await cli.fetch_events(followers_filter, relay_timeout)
# print(followers)
# Negentropy reconciliation
@ -135,7 +135,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
followings.append(following)
filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).authors(followings).since(since)
events = await cli.database().query([filter1])
events = await cli.database().query(filter1)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
@ -146,7 +146,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
[definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
definitions.EventDefinitions.KIND_REPOST,
definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
reactions = await cli.database().query([filt])
reactions = await cli.database().query(filt)
if len(reactions.to_vec()) >= self.min_reactions:
ns.finallist[event.id().to_hex()] = len(reactions.to_vec())

15
nostr_dvm/tasks/content_discovery_currently_popular_gallery.py
View File

@ -116,7 +116,7 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
filter1 = Filter().kind(definitions.EventDefinitions.KIND_NIP68_IMAGEEVENT).since(since)
ge_events = await databasegallery.query([filter1])
ge_events = await databasegallery.query(filter1)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(ge_events.to_vec())) + " Events")
@ -155,7 +155,7 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
for id in ids:
ids_str.append(id.to_hex())
filter_nip22 = Filter().kinds([definitions.EventDefinitions.KIND_NIP22_COMMENT]).custom_tag(SingleLetterTag.uppercase(Alphabet.E),
filter_nip22 = Filter().kinds([definitions.EventDefinitions.KIND_NIP22_COMMENT]).custom_tags(SingleLetterTag.uppercase(Alphabet.E),
ids_str).since(since)
dbopts = SyncOptions().direction(SyncDirection.DOWN)
@ -163,14 +163,14 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
await cli.sync(filter_nip22, dbopts)
filter2 = Filter().ids(ids)
events = await cli.fetch_events([filter2], relay_timeout)
events = await cli.fetch_events(filter2, relay_timeout)
for event in events.to_vec():
if event.created_at().as_secs() > timestamp_since:
filt1 = Filter().kinds([definitions.EventDefinitions.KIND_DELETION]).event(event.id()).limit(1)
deletions = await databasegallery.query([filt1])
deletions = await databasegallery.query(filt1)
if len(deletions.to_vec()) > 0:
print("Deleted event, skipping")
continue
@ -179,11 +179,14 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
definitions.EventDefinitions.KIND_REACTION,
definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
filter_nip22 = Filter().kinds([definitions.EventDefinitions.KIND_NIP22_COMMENT]).custom_tag(
filter_nip22 = Filter().kinds([definitions.EventDefinitions.KIND_NIP22_COMMENT]).custom_tags(
SingleLetterTag.uppercase(Alphabet.E),
[event.id().to_hex()])
reactions = await databasegallery.query([filt, filter_nip22])
reactions = await databasegallery.query(filt)
reactions2 = await databasegallery.query(filter_nip22)
reactions.merge(reactions2)
#print("Reactions:" + str(len(reactions.to_vec())))
if len(reactions.to_vec()) >= self.min_reactions:

9
nostr_dvm/tasks/content_discovery_currently_popular_mostr.py
View File

@ -119,7 +119,7 @@ class DicoverContentCurrentlyPopularMostr(DVMTaskInterface):
filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
events = await database.query([filter1])
events = await database.query(filter1)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
ns.finallist = {}
@ -131,7 +131,7 @@ class DicoverContentCurrentlyPopularMostr(DVMTaskInterface):
[EventDefinitions.KIND_ZAP, EventDefinitions.KIND_REPOST,
EventDefinitions.KIND_REACTION,
EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
reactions = await database.query([filt])
reactions = await database.query(filt)
if len(reactions.to_vec()) >= self.min_reactions:
ns.finallist[event.id().to_hex()] = len(reactions.to_vec())
@ -209,7 +209,10 @@ class DicoverContentCurrentlyPopularMostr(DVMTaskInterface):
# RECONCOILE NOT POSSIBLE ON THESE RELAYS SO WE FETCH AB BUNCH (will be stored in db)
try:
events = await cli.fetch_events([filter1, filter2, filter3], relay_timeout_long)
events1 = await cli.fetch_events(filter1, relay_timeout_long)
events2 = await cli.fetch_events(filter2, relay_timeout_long)
events3 = await cli.fetch_events(filter3, relay_timeout_long)
events = events1.merge(events2).merge(events3)
except Exception as e:
print(e)
# Do not delete profiles

6
nostr_dvm/tasks/content_discovery_currently_popular_nonfollowers.py
View File

@ -157,7 +157,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
await cli.connect()
user = PublicKey.parse(options["user"])
followers_filter = Filter().author(user).kinds([Kind(3)])
followers = await cli.fetch_events([followers_filter], relay_timeout)
followers = await cli.fetch_events(followers_filter, relay_timeout)
if len(followers.to_vec()) > 0:
newest = 0
best_entry = followers.to_vec()[0]
@ -183,7 +183,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
events = await self.database.query([filter1])
events = await self.database.query(filter1)
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
ns.finallist = {}
@ -196,7 +196,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
[definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
definitions.EventDefinitions.KIND_REPOST,
definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
reactions = await self.database.query([filt])
reactions = await self.database.query(filt)
if len(reactions.to_vec()) >= self.min_reactions:
ns.finallist[event.id().to_hex()] = len(reactions.to_vec())

21
nostr_dvm/tasks/content_discovery_currently_popular_topic.py
View File

@ -4,7 +4,7 @@ import os
from datetime import timedelta
from nostr_sdk import Timestamp, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
ClientBuilder, Filter, SyncOptions, SyncDirection, init_logger, LogLevel, Kind
ClientBuilder, Filter, SyncOptions, SyncDirection, init_logger, LogLevel, Kind, Events
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils import definitions
@ -154,12 +154,19 @@ class DicoverContentCurrentlyPopularbyTopic(DVMTaskInterface):
timestamp_since = Timestamp.now().as_secs() - self.db_since
since = Timestamp.from_secs(timestamp_since)
filters = []
for word in self.search_list:
filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(word)
filters.append(filter)
if len(self.search_list) == 0:
print("Search List empty")
return {}
filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(self.search_list[0])
events = await self.database.query(filter)
for word in self.search_list[1:]:
filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(word)
evts = await self.database.query(filter)
events.merge(evts)
events = await self.database.query(filters)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
ns.finallist = {}
@ -172,7 +179,7 @@ class DicoverContentCurrentlyPopularbyTopic(DVMTaskInterface):
[definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
definitions.EventDefinitions.KIND_REPOST,
definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
reactions = await self.database.query([filt])
reactions = await self.database.query(filt)
if len(reactions.to_vec()) >= self.min_reactions:
ns.finallist[event.id().to_hex()] = len(reactions.to_vec())

4
nostr_dvm/tasks/content_discovery_currently_popular_tweets.py
View File

@ -141,7 +141,7 @@ class DicoverContentCurrentlyPopularTweets(DVMTaskInterface):
filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since)
events = await self.database.query([filter1])
events = await self.database.query(filter1)
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
ns.finallist = {}
@ -161,7 +161,7 @@ class DicoverContentCurrentlyPopularTweets(DVMTaskInterface):
[definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
definitions.EventDefinitions.KIND_REPOST,
definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
reactions = await self.database.query([filt])
reactions = await self.database.query(filt)
if len(reactions.to_vec()) >= self.min_reactions:
ns.finallist[event.id().to_hex()] = len(reactions.to_vec())

14
nostr_dvm/tasks/content_discovery_latest_one_per_follower.py
View File

@ -88,7 +88,7 @@ class Discoverlatestperfollower(DVMTaskInterface):
step = 20
followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
followers = await cli.fetch_events([followers_filter], relay_timeout)
followers = await cli.fetch_events(followers_filter, relay_timeout)
if len(followers.to_vec()) > 0:
result_list = []
@ -128,17 +128,21 @@ class Discoverlatestperfollower(DVMTaskInterface):
await cli.add_relay(relay)
await cli.connect()
filters = []
for i in range(i, i + st):
user = PublicKey.parse(users[i])
filter1 = (Filter().author(user).kind(Kind(1))
.limit(1))
event_from_authors = await cli.fetch_events(filter1, relay_timeout_long)
for i in range(i+1, i + st):
try:
user = PublicKey.parse(users[i])
filter1 = (Filter().author(user).kind(Kind(1))
.limit(1))
filters.append(filter1)
events = await cli.fetch_events(filter1, relay_timeout_long)
event_from_authors.merge(events)
except Exception as e:
print(e)
event_from_authors = await cli.fetch_events(filters, relay_timeout_long)
for author in event_from_authors.to_vec():
if instance.dic[author.author().to_hex()] is None:
instance.dic[author.author().to_hex()] = author

4
nostr_dvm/tasks/content_discovery_on_this_day.py
View File

@ -113,7 +113,7 @@ class DicoverContentOnThisDay(DVMTaskInterface):
filter1 = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).until(until)
events = await database.query([filter1])
events = await database.query(filter1)
print(len(events.to_vec()))
if self.dvm_config.LOGLEVEL.value >= LogLevel.DEBUG.value:
print("[" + self.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
@ -123,7 +123,7 @@ class DicoverContentOnThisDay(DVMTaskInterface):
filt = Filter().kinds([definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REPOST,
definitions.EventDefinitions.KIND_REACTION,
definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
reactions = await database.query([filt])
reactions = await database.query(filt)
if len(reactions.to_vec()) >= self.min_reactions:
ns.finallist[event.id().to_hex()] = len(reactions.to_vec())

2
nostr_dvm/tasks/discovery_bot_farms.py
View File

@ -89,7 +89,7 @@ class DiscoveryBotFarms(DVMTaskInterface):
# Query events from database
filter1 = Filter().kind(Kind(0))
events = await cli.database().query([filter1])
events = await cli.database().query(filter1)
result_list = []
print("Events: " + str(len(events.to_vec())))

4
nostr_dvm/tasks/discovery_censor_wot.py
View File

@ -92,7 +92,7 @@ class DiscoverReports(DVMTaskInterface):
# if we don't add users, e.g. by a wot, we check all our followers.
if len(pubkeys) == 0:
followers_filter = Filter().author(PublicKey.parse(options["sender"])).kind(Kind(3))
followers = await cli.fetch_events([followers_filter], relay_timeout)
followers = await cli.fetch_events(followers_filter, relay_timeout)
if len(followers.to_vec()) > 0:
result_list = []
@ -113,7 +113,7 @@ class DiscoverReports(DVMTaskInterface):
options["since_days"]) # TODO make this an option, 180 days for now
since = Timestamp.from_secs(ago)
kind1984_filter = Filter().authors(pubkeys).kind(Kind(1984)).since(since)
reports = await cli.fetch_events([kind1984_filter], relay_timeout)
reports = await cli.fetch_events(kind1984_filter, relay_timeout)
bad_actors = []
ns.dic = {}

23
nostr_dvm/tasks/discovery_inactive_follows.py
View File

@ -1,7 +1,6 @@
import asyncio
import json
import os
from datetime import timedelta
from threading import Thread
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
@ -77,7 +76,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
opts = (Options().relay_limits(relaylimits))
cli = ClientBuilder().signer(NostrSigner.keys(keys)).opts(opts).build()
for relay in self.dvm_config.RELAY_LIST:
for relay in self.dvm_config.SYNC_DB_RELAY_LIST:
await cli.add_relay(relay)
await cli.add_relay("wss://nostr.band")
@ -87,8 +86,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
step = 20
followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
followers = await cli.fetch_events([followers_filter], relay_timeout)
followers = await cli.fetch_events(followers_filter, relay_timeout)
if len(followers.to_vec()) > 0:
result_list = []
newest = 0
@ -100,10 +98,6 @@ class DiscoverInactiveFollows(DVMTaskInterface):
newest = entry.created_at().as_secs()
best_entry = entry
print(best_entry.as_json())
print(len(best_entry.tags().to_vec()))
print(best_entry.created_at().as_secs())
print(Timestamp.now().as_secs())
followings = []
ns.dic = {}
tagcount = 0
@ -124,15 +118,16 @@ class DiscoverInactiveFollows(DVMTaskInterface):
keys = Keys.parse(self.dvm_config.PRIVATE_KEY)
cli = Client(NostrSigner.keys(keys))
for relay in self.dvm_config.RELAY_LIST:
for relay in self.dvm_config.SYNC_DB_RELAY_LIST:
await cli.add_relay(relay)
await cli.connect()
filter1 = Filter().author(PublicKey.parse(users[i])).since(notactivesince).limit(1)
event_from_authors = await cli.fetch_events(filter1, relay_timeout_long)
for j in range(i+1, i + st):
filter1 = Filter().author(PublicKey.parse(users[j])).since(notactivesince).limit(1)
events = await cli.fetch_events(filter1, relay_timeout_long)
event_from_authors.merge(events)
filters = []
for i in range(i, i + st):
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():
instance.dic[author.author().to_hex()] = "True"
print(str(i) + "/" + str(len(users)))

11
nostr_dvm/tasks/discovery_nonfollowers.py
View File

@ -82,7 +82,7 @@ class DiscoverNonFollowers(DVMTaskInterface):
step = 20
followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
followers = await cli.fetch_events([followers_filter], relay_timeout)
followers = await cli.fetch_events(followers_filter, relay_timeout)
if len(followers.to_vec()) > 0:
result_list = []
@ -111,11 +111,12 @@ class DiscoverNonFollowers(DVMTaskInterface):
await cli.add_relay(relay)
await cli.connect()
for i in range(i, i + st):
filters = []
filter1 = Filter().author(PublicKey.parse(users[i])).kind(Kind(3))
followers = await cli.fetch_events(filter1, relay_timeout)
for i in range(i+1, i + st):
filter1 = Filter().author(PublicKey.parse(users[i])).kind(Kind(3))
filters.append(filter1)
followers = await cli.fetch_events(filters, relay_timeout)
follower = await cli.fetch_events(filter1, relay_timeout)
followers.merge(follower)
if len(followers.to_vec()) > 0:
result_list = []

4
nostr_dvm/tasks/discovery_trending_notes_gleasonator.py
View File

@ -79,10 +79,10 @@ class TrendingNotesGleasonator(DVMTaskInterface):
ltags = ["#e", "pub.ditto.trends"]
authors = [PublicKey.parse("db0e60d10b9555a39050c258d460c5c461f6d18f467aa9f62de1a728b8a891a4")]
notes_filter = Filter().authors(authors).kind(Kind(1985)).custom_tag(SingleLetterTag.lowercase(Alphabet.L),
notes_filter = Filter().authors(authors).kind(Kind(1985)).custom_tags(SingleLetterTag.lowercase(Alphabet.L),
ltags)
events = await cli.fetch_events([notes_filter], relay_timeout_long)
events = await cli.fetch_events(notes_filter, relay_timeout_long)
result_list = []
if len(events.to_vec()) > 0:

2
nostr_dvm/tasks/people_discovery_mywot.py
View File

@ -247,7 +247,7 @@ async def analyse_users(user_ids=None, dunbar=100000000):
database = NostrDatabase.lmdb("db/nostr_followlists.db")
followers_filter = Filter().authors(user_keys).kind(Kind(3))
followers = await database.query([followers_filter])
followers = await database.query(followers_filter)
allfriends = []
if len(followers.to_vec()) > 0:
for follower in followers.to_vec():

2
nostr_dvm/tasks/people_discovery_wot.py
View File

@ -251,7 +251,7 @@ async def analyse_users(user_ids=None, dunbar=100000000):
database = NostrDatabase.lmdb("db/nostr_followlists.db")
followers_filter = Filter().authors(user_keys).kind(Kind(3))
followers = await database.query([followers_filter])
followers = await database.query(followers_filter)
allfriends = []
if len(followers.to_vec()) > 0:
for follower in followers.to_vec():

2
nostr_dvm/tasks/search_users.py
View File

@ -94,7 +94,7 @@ class SearchUser(DVMTaskInterface):
# Query events from database
filter1 = Filter().kind(Kind(0))
events = await cli.database().query([filter1])
events = await cli.database().query(filter1)
result_list = []
print("Events: " + str(len(events.to_vec())))

2
nostr_dvm/utils/database_utils.py
View File

@ -279,7 +279,7 @@ async def fetch_user_metadata(npub, client):
pk = PublicKey.parse(npub)
print(f"\nGetting profile metadata for {pk.to_bech32()}...")
profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
events = await client.fetch_events([profile_filter], relay_timeout)
events = await client.fetch_events(profile_filter, relay_timeout)
if len(events.to_vec()) > 0:
latest_entry = events.to_vec()[0]
latest_time = 0

2
nostr_dvm/utils/definitions.py
View File

@ -13,6 +13,8 @@ class EventDefinitions:
KIND_REPOST = Kind(6)
KIND_REACTION = Kind(7)
KIND_NIP68_IMAGEEVENT = Kind(20)
KIND_GIFTWRAP = Kind(59)
KIND_PRIVATE_DM = Kind(60)
KIND_NIP94_METADATA = Kind(1063)
KIND_NIP22_COMMENT = Kind(1111)
KIND_NIP93_GALLERYENTRY = Kind(1163)

4
nostr_dvm/utils/gallery_utils.py
View File

@ -43,7 +43,7 @@ async def convert_nip93_to_nip68(private_key, relay_list, user_to_import_npub=No
nip93_filter = Filter().kind(Kind(1163)).author(PublicKey.parse(user_to_import_npub))
events = await client.fetch_events([nip93_filter], timedelta(5))
events = await client.fetch_events(nip93_filter, timedelta(5))
events_vec = events.to_vec()
reversed_events_vec = reversed(events_vec)
@ -80,7 +80,7 @@ async def convert_nip93_to_nip68(private_key, relay_list, user_to_import_npub=No
except Exception as e:
print(relay_hint)
e_filter = Filter().id(EventId.parse(eventid)).limit(1)
content_events = await client.fetch_events([e_filter], timedelta(5))
content_events = await client.fetch_events(e_filter, timedelta(5))
if len(content_events.to_vec()) > 0:
content_event = content_events.to_vec()[0]
content = re.sub(r'^https?:\/\/.*[\r\n]*', '', content_event.content(), flags=re.MULTILINE).rstrip()

10
nostr_dvm/utils/nip88_utils.py
View File

@ -36,7 +36,7 @@ def nip88_create_d_tag(name, pubkey, image):
async def fetch_nip88_parameters_for_deletion(keys, eventid, client, dvmconfig):
idfilter = Filter().id(EventId.parse(eventid)).limit(1)
nip88events = await client.fetch_events([idfilter], relay_timeout)
nip88events = await client.fetch_events(idfilter, relay_timeout)
d_tag = ""
if len(nip88events.to_vec()) == 0:
print("Event not found. Potentially gone.")
@ -59,7 +59,7 @@ async def fetch_nip88_parameters_for_deletion(keys, eventid, client, dvmconfig):
async def fetch_nip88_event(keys, eventid, client, dvmconfig):
idfilter = Filter().id(EventId.parse(eventid)).limit(1)
nip88events = await client.fetch_events([idfilter], relay_timeout)
nip88events = await client.fetch_events(idfilter, relay_timeout)
d_tag = ""
if len(nip88events.to_vec()) == 0:
print("Event not found. Potentially gone.")
@ -97,9 +97,9 @@ async def nip88_has_active_subscription(user: PublicKey, tiereventdtag, client:
}
subscriptionfilter = Filter().kind(definitions.EventDefinitions.KIND_NIP88_PAYMENT_RECIPE).pubkey(
PublicKey.parse(receiver_public_key_hex)).custom_tag(SingleLetterTag.uppercase(Alphabet.P),
PublicKey.parse(receiver_public_key_hex)).custom_tags(SingleLetterTag.uppercase(Alphabet.P),
[user.to_hex()]).limit(1)
evts = await client.fetch_events([subscriptionfilter], relay_timeout)
evts = await client.fetch_events(subscriptionfilter, relay_timeout)
if len(evts.to_vec()) > 0:
print(evts.to_vec()[0].as_json())
matchesdtag = False
@ -120,7 +120,7 @@ async def nip88_has_active_subscription(user: PublicKey, tiereventdtag, client:
cancel_filter = Filter().kind(EventDefinitions.KIND_NIP88_STOP_SUBSCRIPTION_EVENT).author(
user).pubkey(PublicKey.parse(receiver_public_key_hex)).event(
EventId.parse(subscription_status["subscriptionId"])).limit(1)
cancel_events = await client.fetch_events([cancel_filter], relay_timeout)
cancel_events = await client.fetch_events(cancel_filter, relay_timeout)
if len(cancel_events.to_vec()) > 0:
if cancel_events.to_vec()[0].created_at().as_secs() > evts[0].created_at().as_secs():
subscription_status["expires"] = True

12
nostr_dvm/utils/nip89_utils.py
View File

@ -41,7 +41,7 @@ async def nip89_announce_tasks(dvm_config, client):
async def fetch_nip89_parameters_for_deletion(keys, eventid, client, dvmconfig, pow=False):
idfilter = Filter().id(EventId.parse(eventid)).limit(1)
nip89events = await client.fetch_events([idfilter], relay_timeout)
nip89events = await client.fetch_events(idfilter, relay_timeout)
d_tag = ""
if len(nip89events.to_vec()) == 0:
print("Event not found. Potentially gone.")
@ -92,8 +92,8 @@ async def nip89_fetch_all_dvms(client):
for i in range(5000, 5999):
ktags.append(str(i))
filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).custom_tag(SingleLetterTag.lowercase(Alphabet.K), ktags)
events = await client.fetch_events([filter], relay_timeout)
filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).custom_tags(SingleLetterTag.lowercase(Alphabet.K), ktags)
events = await client.fetch_events(filter, relay_timeout)
for event in events.to_vec():
print(event.as_json())
@ -101,8 +101,8 @@ async def nip89_fetch_all_dvms(client):
async def nip89_fetch_events_pubkey(client, pubkey, kind):
ktags = [str(kind.as_u16())]
nip89filter = (Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(PublicKey.parse(pubkey)).
custom_tag(SingleLetterTag.lowercase(Alphabet.K), ktags))
events = await client.fetch_events([nip89filter], relay_timeout)
custom_tags(SingleLetterTag.lowercase(Alphabet.K), ktags))
events = await client.fetch_events(nip89filter, relay_timeout)
dvms = {}
for event in events.to_vec():
@ -152,7 +152,7 @@ async def delete_nip_89(dvm_config, pow=True):
await client.add_relay(relay)
await client.connect()
filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(keys.public_key())
events = await client.fetch_events([filter], timedelta(seconds=5))
events = await client.fetch_events(filter, timedelta(seconds=5))
if len(events.to_vec()) == 0:
print("Couldn't find note on relays. Seems they are gone.")

37
nostr_dvm/utils/nostr_utils.py
View File

@ -16,14 +16,14 @@ async def get_event_by_id(event_id_str: str, client: Client, config=None) -> Eve
split = event_id_str.split(":")
if len(split) == 3:
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)
id_filter = Filter().author(pk).custom_tags(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
events = await client.fetch_events(id_filter, relay_timeout)
else:
event_id = EventId.parse(event_id_str)
id_filter = Filter().id(event_id).limit(1)
events = await client.fetch_events([id_filter], relay_timeout)
events = await client.fetch_events(id_filter, relay_timeout)
if len(events.to_vec()) > 0:
return events.to_vec()[0]
@ -32,8 +32,8 @@ async def get_event_by_id(event_id_str: str, client: Client, config=None) -> Eve
return None
async def get_events_async(client, filter, timeout):
events = await client.fetch_events([filter], timedelta(seconds=timeout))
async def get_events_async(client, filter1, timeout):
events = await client.fetch_events(filter1, timedelta(seconds=timeout))
return events.to_vec()
@ -44,8 +44,8 @@ async def get_events_by_ids(event_ids, client: Client, config=None) -> List | No
split = event_id.split(":")
if len(split) == 3:
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)
id_filter = Filter().author(pk).custom_tags(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
events = await client.fetch_events(id_filter, relay_timeout)
else:
if str(event_id).startswith("nevent"):
@ -57,7 +57,7 @@ async def get_events_by_ids(event_ids, client: Client, config=None) -> List | No
search_ids.append(event_id)
id_filter = Filter().ids(search_ids)
events = await client.fetch_events([id_filter], relay_timeout)
events = await client.fetch_events(id_filter, relay_timeout)
if len(events.to_vec()) > 0:
return events.to_vec()
@ -66,9 +66,10 @@ async def get_events_by_ids(event_ids, client: Client, config=None) -> List | No
async def get_events_by_id(event_ids: list, client: Client, config=None) -> list[Event] | None:
id_filter = Filter().ids(event_ids)
# events = asyncio.run(get_events_async(client, id_filter, config.RELAY_TIMEOUT))
events = await client.fetch_events([id_filter], relay_timeout)
events = await client.fetch_events(id_filter, relay_timeout)
if len(events.to_vec()) > 0:
return events.to_vec()
else:
@ -89,7 +90,7 @@ async def get_referenced_event_by_id(event_id, client, dvm_config, kinds) -> Eve
job_id_filter = Filter().kinds(kinds).event(event_id).limit(1)
else:
job_id_filter = Filter().event(event_id).limit(1)
events = await client.fetch_events([job_id_filter], relay_timeout)
events = await client.fetch_events(job_id_filter, relay_timeout)
if len(events.to_vec()) > 0:
return events.to_vec()[0]
@ -104,8 +105,8 @@ async def get_inbox_relays(event_to_send: Event, client: Client, dvm_config):
ptag = PublicKey.parse(tag.as_vec()[1])
ptags.append(ptag)
filter = Filter().kinds([EventDefinitions.KIND_RELAY_ANNOUNCEMENT]).authors(ptags)
events = await client.fetch_events([filter], relay_timeout)
filter1 = Filter().kinds([EventDefinitions.KIND_RELAY_ANNOUNCEMENT]).authors(ptags)
events = await client.fetch_events(filter1, relay_timeout)
if len(events.to_vec()) == 0:
return []
else:
@ -128,8 +129,8 @@ async def get_dm_relays(event_to_send: Event, client: Client, dvm_config):
ptag = PublicKey.parse(tag.as_vec()[1])
ptags.append(ptag)
filter = Filter().kinds([Kind(10050)]).authors(ptags)
events = await client.fetch_events([filter], relay_timeout)
filter1 = Filter().kinds([Kind(10050)]).authors(ptags)
events = await client.fetch_events(filter1, relay_timeout)
if len(events.to_vec()) == 0:
return []
else:
@ -157,8 +158,8 @@ async def get_main_relays(event_to_send: Event, client: Client, dvm_config):
await client.add_relay(relay)
await client.connect()
filter = Filter().kinds([EventDefinitions.KIND_FOLLOW_LIST]).authors(ptags)
events = await client.fetch_events([filter], relay_timeout)
filter1 = Filter().kinds([EventDefinitions.KIND_FOLLOW_LIST]).authors(ptags)
events = await client.fetch_events(filter1, relay_timeout)
if len(events.to_vec()) == 0:
return []
else:
@ -207,9 +208,7 @@ async def send_event_outbox(event: Event, client, dvm_config) -> SendEventOutput
# 5. Otherwise, we create a new Outbox client with the inbox relays and send the event there
relaylimits = RelayLimits.disable()
connection = Connection().embedded_tor().target(ConnectionTarget.ONION)
# connection = Connection().addr("127.0.0.1:9050").target(ConnectionTarget.ONION)
connection = Connection().addr("127.0.0.1:9050").target(ConnectionTarget.ONION)
opts = Options().relay_limits(relaylimits).connection(connection)
sk = SecretKey.parse(dvm_config.PRIVATE_KEY)
keys = Keys.parse(sk.to_hex())

6
nostr_dvm/utils/nut_wallet_utils.py
View File

@ -116,7 +116,7 @@ class NutZapWallet:
wallet_filter = Filter().kind(EventDefinitions.KIND_NUT_WALLET).author(keys.public_key())
# relay_timeout = EventSource.relays(timedelta(seconds=10))
wallets = await client.fetch_events([wallet_filter], timedelta(seconds=10))
wallets = await client.fetch_events(wallet_filter, timedelta(seconds=10))
if len(wallets.to_vec()) > 0:
@ -190,7 +190,7 @@ class NutZapWallet:
# Now all proof events
proof_filter = Filter().kind(Kind(7375)).author(keys.public_key())
proof_events = await client.fetch_events([proof_filter], timedelta(seconds=5))
proof_events = await client.fetch_events(proof_filter, timedelta(seconds=5))
latest_proof_sec = 0
latest_proof_event_id = EventId
@ -443,7 +443,7 @@ class NutZapWallet:
async def fetch_mint_info_event(self, pubkey, client):
mint_info_filter = Filter().kind(Kind(10019)).author(PublicKey.parse(pubkey))
preferences = await client.fetch_events([mint_info_filter], timedelta(seconds=5))
preferences = await client.fetch_events(mint_info_filter, timedelta(seconds=5))
mints = []
relays = []
pubkey = ""

2
nostr_dvm/utils/nwc_tools.py
View File

@ -70,7 +70,7 @@ async def nwc_test(nwc_server):
keys = Keys.parse(check_and_set_private_key("test"))
# we zap npub1nxa4tywfz9nqp7z9zp7nr7d4nchhclsf58lcqt5y782rmf2hefjquaa6q8's profile 21 sats and say Cool stuff
pubkey = PublicKey.from_bech32("npub1nxa4tywfz9nqp7z9zp7nr7d4nchhclsf58lcqt5y782rmf2hefjquaa6q8")
pubkey = PublicKey.parse("npub1nxa4tywfz9nqp7z9zp7nr7d4nchhclsf58lcqt5y782rmf2hefjquaa6q8")
bolt11 = zaprequest("hype@bitcoinfixesthis.org", 21, "Cool Stuff", None,
pubkey, keys, DVMConfig.RELAY_LIST)

4
nostr_dvm/utils/wot_utils.py
View File

@ -53,7 +53,7 @@ async def get_following(pks, max_time_request=10, newer_than_time=None, dvm_conf
await cli.connect()
events = await cli.fetch_events([filter], relay_timeout)
events = await cli.fetch_events(filter, relay_timeout)
for relay in dvm_config.SYNC_DB_RELAY_LIST:
await cli.force_remove_relay(relay)
@ -596,7 +596,7 @@ async def get_metadata(npub):
profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
events_struct = await client.fetch_events([profile_filter], relay_timeout)
events_struct = await client.fetch_events(profile_filter, relay_timeout)
events = events_struct.to_vec()
if len(events) > 0:
try:

2
setup.py
View File

@ -14,7 +14,7 @@ setup(
long_description=LONG_DESCRIPTION,
packages=find_packages(include=['nostr_dvm', 'nostr_dvm.*']),
install_requires=["nostr-sdk==0.38.0",
install_requires=["nostr-sdk==0.39.0",
"bech32==1.2.0",
"pycryptodome==3.20.0",
"yt-dlp==2024.11.04",

6
tests/bot.py
View File

@ -70,18 +70,14 @@ def playground():
bot_config.SUPPORTED_DVMS.append(translator) # We add translator to the bot
framework.add(translator)
framework.run()
admin_config = AdminConfig()
admin_config.REBROADCAST_NIP65_RELAY_LIST = True
admin_config.UPDATE_PROFILE = True
x = threading.Thread(target=Bot, args=([bot_config, admin_config]))
x.start()
# Keep the main function alive for libraries that require it, like openai
# keep_alive()
framework.run()

2
tests/db.py
View File

@ -32,7 +32,7 @@ async def reconcile_db():
async def do_some_work():
database = NostrDatabase.lmdb("nostr.db")
f = Filter().author(keys.public_key()).limit(10)
events = await database.query([f])
events = await database.query(f)
for event in events.to_vec():
print(event.as_json())

4
tests/ditto.py
View File

@ -24,9 +24,9 @@ async def main():
ltags = ["#e", "pub.ditto.trends"]
itags = [str(SingleLetterTag.lowercase(Alphabet.E))]
authors = [PublicKey.parse("db0e60d10b9555a39050c258d460c5c461f6d18f467aa9f62de1a728b8a891a4")]
notes_filter = Filter().authors(authors).custom_tag(SingleLetterTag.lowercase(Alphabet.L), ltags)
notes_filter = Filter().authors(authors).custom_tags(SingleLetterTag.lowercase(Alphabet.L), ltags)
events_struct = await cli.fetch_events([notes_filter], relay_timeout_long)
events_struct = await cli.fetch_events(notes_filter, relay_timeout_long)
events = events_struct.to_vec()

17
tests/generic_dvm_autotopic_feed.py
View File

@ -163,7 +163,7 @@ def playground(announce=False):
print(options["request_event_author"])
filterauth = Filter().kind(definitions.EventDefinitions.KIND_NOTE).author(author).limit(100)
event_struct = await cli.fetch_events([filterauth], relay_timeout)
event_struct = await cli.fetch_events(filterauth, relay_timeout)
text = ""
if len(event_struct.to_vec()) == 0:
@ -204,11 +204,16 @@ def playground(announce=False):
if len(keywords) == 0:
return json.dumps([])
filters = []
for keyword in keywords:
filters.append(Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(" " + keyword.lstrip().rstrip() + " "))
filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(
" " + keywords[0].lstrip().rstrip() + " ")
events = await database.query(filter)
for keyword in keywords[1:]:
filter = Filter().kind(definitions.EventDefinitions.KIND_NOTE).since(since).search(" " + keyword.lstrip().rstrip() + " ")
evts = await database.query(filter)
events.merge(evts)
events = await database.query(filters)
print("[" + dvm.dvm_config.NIP89.NAME + "] Considering " + str(len(events.to_vec())) + " Events")
ns.finallist = {}
@ -221,7 +226,7 @@ def playground(announce=False):
[definitions.EventDefinitions.KIND_ZAP, definitions.EventDefinitions.KIND_REACTION,
definitions.EventDefinitions.KIND_REPOST,
definitions.EventDefinitions.KIND_NOTE]).event(event.id()).since(since)
reactions = await database.query([filt])
reactions = await database.query(filt)
if len(reactions.to_vec()) >= 1:
ns.finallist[event.id().to_hex()] = len(reactions.to_vec())

9
tests/simplebot.py
View File

@ -27,14 +27,15 @@ async def test():
now = Timestamp.now()
nip04_filter = Filter().pubkey(pk).kind(Kind.from_enum(KindEnum.ENCRYPTED_DIRECT_MESSAGE())).since(now)
nip59_filter = Filter().pubkey(pk).kind(Kind.from_enum(KindEnum.GIFT_WRAP())).limit(0)
await client.subscribe([nip04_filter, nip59_filter], None)
nip04_filter = Filter().pubkey(pk).kind(Kind(KindEnum.ENCRYPTED_DIRECT_MESSAGE())).since(now)
nip59_filter = Filter().pubkey(pk).kind(Kind((KindEnum.GIFT_WRAP()))).limit(0)
await client.subscribe(nip04_filter)
await client.subscribe(nip59_filter)
class NotificationHandler(HandleNotification):
async def handle(self, relay_url, subscription_id, event: Event):
print(f"Received new event from {relay_url}: {event.as_json()}")
if event.kind().as_enum() == KindEnum.ENCRYPTED_DIRECT_MESSAGE():
if event.kind().as_u16() == KindEnum.ENCRYPTED_DIRECT_MESSAGE():
print("Decrypting NIP04 event")
try:
msg = nip04_decrypt(sk, event.author(), event.content())

3
tests/test_dvm_client.py
View File

@ -414,7 +414,8 @@ async def nostr_client():
if kind not in kinds:
kinds.append(Kind(kind))
dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()).pubkey(pk))
await client.subscribe([dm_zap_filter, dvm_filter], None)
await client.subscribe(dm_zap_filter, None)
await client.subscribe(dvm_filter, None)
# await nostr_client_test_translation("This is the result of the DVM in spanish", "text", "es", 20, 20)
# await nostr_client_test_translation("note1p8cx2dz5ss5gnk7c59zjydcncx6a754c0hsyakjvnw8xwlm5hymsnc23rs", "event", "es", 20,20)

4
tests/test_events.py
View File

@ -53,7 +53,7 @@ async def test_referred_events(client, event_id, kinds=None):
else:
job_id_filter = Filter().event(EventId.parse(event_id))
event_struct = await client.fetch_events([job_id_filter], relay_timeout)
event_struct = await client.fetch_events(job_id_filter, relay_timeout)
events = event_struct.to_vec()
if len(events) > 0:
@ -129,7 +129,7 @@ async def test_search_by_user_since_days(client, pubkey, days, prompt):
since = Timestamp.from_secs(dif)
filterts = Filter().search(prompt).author(pubkey).kinds([Kind(1)]).since(since)
event_struct = await client.fetch_events([filterts], relay_timeout)
event_struct = await client.fetch_events(filterts, relay_timeout)
events = event_struct.to_vec()
if len(events) > 0:

4
tests/wot.py
View File

@ -32,7 +32,7 @@ async def getmetadata(npub):
await client.connect()
profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
event_struct = await client.fetch_events([profile_filter], relay_timeout)
event_struct = await client.fetch_events(profile_filter, relay_timeout)
events = event_struct.to_vec()
if len(events) > 0:
try:
@ -82,7 +82,7 @@ async def analyse_users(user_ids=None):
database = NostrDatabase.lmdb("db/nostr_followlists.db")
followers_filter = Filter().authors(user_keys).kind(Kind(3))
followers = await database.query([followers_filter])
followers = await database.query(followers_filter)
allfriends = []
if len(followers.to_vec()) > 0:
for follower in followers.to_vec():

6
tutorials/03_client.py
View File

@ -72,7 +72,11 @@ async def nostr_client(target_dvm_npub):
kinds.append(Kind(kind))
dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()).pubkey(pk))
await client.subscribe([dm_zap_filter, dvm_filter], None)
await client.subscribe(dm_zap_filter, None)
await client.subscribe(dvm_filter, None)
# This will send a request to the DVM
await nostr_client_generic_test(target_dvm_npub)

2
tutorials/09_nutzap_client.py
View File

@ -58,7 +58,7 @@ async def nostr_client(target_dvm_npub):
kinds.append(Kind(kind))
dvm_filter = (Filter().kinds(kinds).since(Timestamp.now()).pubkey(pk))
await client.subscribe([dvm_filter], None)
await client.subscribe(dvm_filter, None)
# This will send a request to the DVM
await nostr_client_generic_test(target_dvm_npub)

2
tutorials/10_delete_nip89.py
View File

@ -25,7 +25,7 @@ async def delete_nip_89(private_key, relay_list, pow=True):
await client.add_relay(relay)
await client.connect()
filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(keys.public_key())
events = await client.fetch_events([filter], timedelta(seconds=5))
events = await client.fetch_events(filter, timedelta(seconds=5))
if len(events.to_vec()) == 0:
print("Couldn't find note on relays. Seems they are gone.")