highperfocused/nostrdvm
1
0
Fork 0
mirror of https://github.com/believethehype/nostrdvm.git synced 2025-06-01 13:59:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

going back to rust-sdk 0.33

Browse Source
This commit is contained in:
Believethehype 2024-08-20 18:40:46 +02:00
parent eaa41aa75a
commit 1a4067e5d1
22 changed files with 68 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
nostr_dvm/subscription.py
View File

@ -7,8 +7,7 @@ import time
from datetime import timedelta
from nostr_sdk import (Keys, Client, Timestamp, Filter, nip04_decrypt, HandleNotification, EventBuilder, PublicKey,
Options, Tag, Event, nip04_encrypt, NostrSigner, EventId, Nip19Event, nip44_decrypt, Kind,
EventSource)
Options, Tag, Event, nip04_encrypt, NostrSigner, EventId, Nip19Event, nip44_decrypt, Kind)
from nostr_dvm.utils.database_utils import fetch_user_metadata
from nostr_dvm.utils.definitions import EventDefinitions
@ -249,8 +248,7 @@ class Subscription:
subscriptionfilter = Filter().kind(EventDefinitions.KIND_NIP88_SUBSCRIBE_EVENT).author(
PublicKey.parse(subscriber)).limit(1)
source = EventSource.relays(timedelta(seconds=5))
evts = await self.client.get_events_of([subscriptionfilter], source)
evts = await self.client.get_events_of([subscriptionfilter], timedelta(seconds=3))
if len(evts) > 0:
event7001id = evts[0].id().to_hex()
print(evts[0].as_json())
@ -287,8 +285,7 @@ class Subscription:
if tier_dtag == "" or len(zaps) == 0:
tierfilter = Filter().id(EventId.parse(subscription_event_id))
source = EventSource.relays(timedelta(seconds=5))
evts = await self.client.get_events_of([tierfilter], source)
evts = await self.client.get_events_of([tierfilter], timedelta(seconds=3))
if len(evts) > 0:
for tag in evts[0].tags():
if tag.as_vec()[0] == "d":

7
nostr_dvm/tasks/advanced_search.py
View File

@ -1,8 +1,7 @@
import json
import os
from datetime import timedelta
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
EventSource
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils.admin_utils import AdminConfig
@ -132,8 +131,8 @@ class AdvancedSearch(DVMTaskInterface):
else:
notes_filter = Filter().kind(Kind(1)).authors(userkeys).search(options["search"]).since(
search_since).until(search_until).limit(options["max_results"])
source = EventSource.relays(timedelta(seconds=5))
events = await cli.get_events_of([notes_filter], timedelta(seconds=source))
events = await cli.get_events_of([notes_filter], timedelta(seconds=5))
result_list = []
if len(events) > 0:

5
nostr_dvm/tasks/content_discovery_currently_popular_followers.py
View File

@ -4,7 +4,7 @@ import os
from datetime import timedelta
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
ClientBuilder, Filter, NegentropyOptions, NegentropyDirection, init_logger, LogLevel, Event, EventId, Kind, \
RelayOptions, RelayLimits, EventSource
RelayOptions, RelayLimits
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils import definitions
@ -113,8 +113,7 @@ class DicoverContentCurrentlyPopularFollowers(DVMTaskInterface):
user = PublicKey.parse(options["user"])
followers_filter = Filter().author(user).kinds([Kind(3)])
source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
followers = await cli.get_events_of([followers_filter], source)
followers = await cli.get_events_of([followers_filter], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
#print(followers)
# Negentropy reconciliation

5
nostr_dvm/tasks/content_discovery_currently_popular_gallery.py
View File

@ -4,7 +4,7 @@ import os
from datetime import timedelta
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
ClientBuilder, Filter, NegentropyOptions, NegentropyDirection, init_logger, LogLevel, Event, EventId, Kind, \
RelayOptions, RelayLimits, EventSource
RelayOptions, RelayLimits
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils import definitions
@ -172,8 +172,7 @@ class DicoverContentCurrentlyPopularGallery(DVMTaskInterface):
filter2 = Filter().ids(ids)
source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
events = await cli.get_events_of([filter2], source)
events = await cli.get_events_of([filter2], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
print(len(events))

5
nostr_dvm/tasks/content_discovery_currently_popular_mostr.py
View File

@ -4,7 +4,7 @@ import os
from datetime import timedelta
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
ClientBuilder, Filter, NegentropyOptions, NegentropyDirection, init_logger, LogLevel, Event, EventId, Kind, \
RelayOptions, EventSource
RelayOptions
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils import definitions
@ -256,8 +256,7 @@ class DicoverContentCurrentlyPopularMostr(DVMTaskInterface):
#await cli.reconcile(filter3, dbopts)
# RECONCOILE NOT POSSIBLE ON THESE RELAYS SO WE FETCH AB BUNCH (will be stored in db)
source = EventSource.relays(timedelta(seconds=10))
events = await cli.get_events_of([filter1, filter2, filter3], source)
events = await cli.get_events_of([filter1, filter2, filter3], None)
# Do not delete profiles
await cli.database().delete(Filter().kinds([EventDefinitions.KIND_NOTE, EventDefinitions.KIND_ZAP, EventDefinitions.KIND_REPOST, EventDefinitions.KIND_REACTION]).until(Timestamp.from_secs(

5
nostr_dvm/tasks/content_discovery_currently_popular_nonfollowers.py
View File

@ -4,7 +4,7 @@ import os
from datetime import timedelta
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, NostrDatabase, \
ClientBuilder, Filter, NegentropyOptions, NegentropyDirection, init_logger, LogLevel, Event, EventId, Kind, \
RelayLimits, EventSource
RelayLimits
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils import definitions
@ -154,8 +154,7 @@ class DicoverContentCurrentlyPopularNonFollowers(DVMTaskInterface):
await cli.connect()
user = PublicKey.parse(options["user"])
followers_filter = Filter().author(user).kinds([Kind(3)])
source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
followers = await cli.get_events_of([followers_filter], source)
followers = await cli.get_events_of([followers_filter], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
if len(followers) > 0:
newest = 0
best_entry = followers[0]

8
nostr_dvm/tasks/content_discovery_latest_one_per_follower.py
View File

@ -5,7 +5,7 @@ from datetime import timedelta
from threading import Thread
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
RelayLimits, Event, EventSource
RelayLimits, Event
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils.admin_utils import AdminConfig
@ -92,8 +92,7 @@ class Discoverlatestperfollower(DVMTaskInterface):
step = 20
followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
source = EventSource.relays(timedelta(seconds=5))
followers = await cli.get_events_of([followers_filter], source)
followers = await cli.get_events_of([followers_filter], timedelta(seconds=5))
if len(followers) > 0:
result_list = []
@ -141,8 +140,7 @@ class Discoverlatestperfollower(DVMTaskInterface):
filter1 = (Filter().author(PublicKey.from_hex(users[i])).kind(Kind(1))
.limit(1))
filters.append(filter1)
source = EventSource.relays(timedelta(seconds=10))
event_from_authors = await cli.get_events_of(filters, source)
event_from_authors = await cli.get_events_of(filters, timedelta(seconds=10))
for author in event_from_authors:
if instance.dic[author.author().to_hex()] is None:
instance.dic[author.author().to_hex()] = author

8
nostr_dvm/tasks/discovery_censor_wot.py
View File

@ -4,7 +4,7 @@ from datetime import timedelta
from threading import Thread
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
RelayLimits, Event, EventSource
RelayLimits, Event
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils.admin_utils import AdminConfig
@ -97,8 +97,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))
source = EventSource.relays(timedelta(seconds=5))
followers = await cli.get_events_of([followers_filter], source)
followers = await cli.get_events_of([followers_filter], timedelta(seconds=5))
if len(followers) > 0:
result_list = []
@ -119,8 +118,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)
source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
reports = await cli.get_events_of([kind1984_filter], source)
reports = await cli.get_events_of([kind1984_filter], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
bad_actors = []
ns.dic = {}

8
nostr_dvm/tasks/discovery_inactive_follows.py
View File

@ -5,7 +5,7 @@ from datetime import timedelta
from threading import Thread
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
RelayLimits, EventSource
RelayLimits
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils.admin_utils import AdminConfig
@ -92,8 +92,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
step = 20
followers_filter = Filter().author(PublicKey.parse(options["user"])).kind(Kind(3))
source = EventSource.relays(timedelta(seconds=5))
followers = await cli.get_events_of([followers_filter], source)
followers = await cli.get_events_of([followers_filter], timedelta(seconds=5))
if len(followers) > 0:
result_list = []
@ -141,8 +140,7 @@ class DiscoverInactiveFollows(DVMTaskInterface):
for i in range(i, i + st):
filter1 = Filter().author(PublicKey.from_hex(users[i])).since(notactivesince).limit(1)
filters.append(filter1)
source = EventSource.relays(timedelta(seconds=10))
event_from_authors = await cli.get_events_of(filters, source)
event_from_authors = await cli.get_events_of(filters, timedelta(seconds=10))
for author in event_from_authors:
instance.dic[author.author().to_hex()] = "True"
print(str(i) + "/" + str(len(users)))

8
nostr_dvm/tasks/discovery_nonfollowers.py
View File

@ -5,7 +5,7 @@ from datetime import timedelta
from threading import Thread
from nostr_sdk import Client, Timestamp, PublicKey, Tag, Keys, Options, SecretKey, NostrSigner, Kind, RelayOptions, \
RelayLimits, EventSource
RelayLimits
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils.admin_utils import AdminConfig
@ -81,8 +81,7 @@ class DiscoverNonFollowers(DVMTaskInterface):
step = 20
followers_filter = Filter().author(PublicKey.from_hex(options["user"])).kind(Kind(3))
source = EventSource.relays(timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
followers = await cli.get_events_of([followers_filter], source)
followers = await cli.get_events_of([followers_filter], timedelta(seconds=self.dvm_config.RELAY_TIMEOUT))
if len(followers) > 0:
result_list = []
@ -119,8 +118,7 @@ class DiscoverNonFollowers(DVMTaskInterface):
filters = []
filter1 = Filter().author(PublicKey.from_hex(users[i])).kind(Kind(3))
filters.append(filter1)
source = EventSource.relays(timedelta(seconds=3))
followers = await cli.get_events_of(filters, source)
followers = await cli.get_events_of(filters, timedelta(seconds=3))
if len(followers) > 0:
result_list = []

6
nostr_dvm/tasks/discovery_trending_notes_gleasonator.py
View File

@ -3,7 +3,7 @@ import os
from datetime import timedelta
from nostr_sdk import Tag, Kind, init_logger, LogLevel, Filter, Timestamp, RelayOptions, Client, NostrSigner, Keys, \
SecretKey, Options, SingleLetterTag, Alphabet, PublicKey, EventSource
SecretKey, Options, SingleLetterTag, Alphabet, PublicKey
from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface, process_venv
from nostr_dvm.utils.admin_utils import AdminConfig
@ -11,6 +11,7 @@ from nostr_dvm.utils.definitions import EventDefinitions
from nostr_dvm.utils.dvmconfig import DVMConfig, build_default_config
from nostr_dvm.utils.nip88_utils import NIP88Config
from nostr_dvm.utils.nip89_utils import NIP89Config, check_and_set_d_tag
from nostr_dvm.utils.nostr_utils import check_and_set_private_key
from nostr_dvm.utils.output_utils import post_process_list_to_events
"""
@ -83,9 +84,8 @@ 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), ltags)
source = EventSource.relays(timedelta(seconds=10))
events = await cli.get_events_of([notes_filter], source)
events = await cli.get_events_of([notes_filter], timedelta(seconds=10))
result_list = []
if len(events) > 0:

5
nostr_dvm/utils/database_utils.py
View File

@ -7,7 +7,7 @@ from dataclasses import dataclass
from datetime import timedelta
from logging import Filter
from nostr_sdk import Timestamp, Keys, PublicKey, EventBuilder, Filter, Kind, EventSource
from nostr_sdk import Timestamp, Keys, PublicKey, EventBuilder, Filter, Kind
from nostr_dvm.utils.nostr_utils import send_event
@ -254,8 +254,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)
source = EventSource.relays(timedelta(seconds=1))
events = await client.get_events_of([profile_filter], source)
events = await client.get_events_of([profile_filter], timedelta(seconds=1))
if len(events) > 0:
latest_entry = events[0]
latest_time = 0

14
nostr_dvm/utils/nip88_utils.py
View File

@ -5,7 +5,7 @@ from pathlib import Path
import dotenv
from nostr_sdk import Filter, Tag, Keys, EventBuilder, Client, EventId, PublicKey, Event, Timestamp, SingleLetterTag, \
Alphabet, Kind, EventSource
Alphabet, Kind
from nostr_dvm.utils import definitions
from nostr_dvm.utils.definitions import EventDefinitions
@ -37,8 +37,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)
source = EventSource.relays(timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
nip88events = await client.get_events_of([idfilter], source)
nip88events = await client.get_events_of([idfilter], timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
d_tag = ""
if len(nip88events) == 0:
print("Event not found. Potentially gone.")
@ -61,8 +60,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)
source = EventSource.relays(timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
nip88events = await client.get_events_of([idfilter], source)
nip88events = await client.get_events_of([idfilter], timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
d_tag = ""
if len(nip88events) == 0:
print("Event not found. Potentially gone.")
@ -101,8 +99,7 @@ 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),
[user.to_hex()]).limit(1)
source = EventSource.relays(timedelta(seconds=5))
evts = await client.get_events_of([subscriptionfilter],source)
evts = await client.get_events_of([subscriptionfilter], timedelta(seconds=3))
if len(evts) > 0:
print(evts[0].as_json())
matchesdtag = False
@ -123,8 +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)
source = EventSource.relays(timedelta(seconds=5))
cancel_events = await client.get_events_of([cancel_filter], source)
cancel_events = await client.get_events_of([cancel_filter], timedelta(seconds=3))
if len(cancel_events) > 0:
if cancel_events[0].created_at().as_secs() > evts[0].created_at().as_secs():
subscription_status["expires"] = True

12
nostr_dvm/utils/nip89_utils.py
View File

@ -4,8 +4,7 @@ from hashlib import sha256
from pathlib import Path
import dotenv
from nostr_sdk import Tag, Keys, EventBuilder, Filter, Alphabet, PublicKey, Client, EventId, SingleLetterTag, Kind, \
EventSource
from nostr_sdk import Tag, Keys, EventBuilder, Filter, Alphabet, PublicKey, Client, EventId, SingleLetterTag, Kind
from nostr_dvm.utils.definitions import EventDefinitions
from nostr_dvm.utils.nostr_utils import send_event
@ -40,8 +39,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.from_hex(eventid)).limit(1)
source = EventSource.relays(timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
nip89events = await client.get_events_of([idfilter], source)
nip89events = await client.get_events_of([idfilter], timedelta(seconds=dvmconfig.RELAY_TIMEOUT))
d_tag = ""
if len(nip89events) == 0:
print("Event not found. Potentially gone.")
@ -87,8 +85,7 @@ async def nip89_fetch_all_dvms(client):
ktags.append(str(i))
filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).custom_tag(SingleLetterTag.lowercase(Alphabet.K), ktags)
source = EventSource.relays(timedelta(seconds=5))
events = await client.get_events_of([filter], source)
events = await client.get_events_of([filter], timedelta(seconds=5))
for event in events:
print(event.as_json())
@ -97,8 +94,7 @@ async def nip89_fetch_events_pubkey(client, pubkey, kind):
ktags = [str(kind.as_u64())]
nip89filter = (Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(PublicKey.parse(pubkey)).
custom_tag(SingleLetterTag.lowercase(Alphabet.K), ktags))
source = EventSource.relays(timedelta(seconds=5))
events = await client.get_events_of([nip89filter], source)
events = await client.get_events_of([nip89filter], timedelta(seconds=4))
dvms = {}
for event in events:

27
nostr_dvm/utils/nostr_utils.py
View File

@ -6,7 +6,7 @@ from typing import List
import dotenv
from nostr_sdk import Filter, Client, Alphabet, EventId, Event, PublicKey, Tag, Keys, nip04_decrypt, Metadata, Options, \
Nip19Event, SingleLetterTag, RelayOptions, RelayLimits, SecretKey, NostrSigner, EventSource
Nip19Event, SingleLetterTag, RelayOptions, RelayLimits, SecretKey, NostrSigner
from nostr_dvm.utils.definitions import EventDefinitions
@ -16,8 +16,7 @@ async def get_event_by_id(event_id: str, client: Client, config=None) -> Event |
if len(split) == 3:
pk = PublicKey.from_hex(split[1])
id_filter = Filter().author(pk).custom_tag(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
source = EventSource.relays(timedelta(seconds=config.RELAY_TIMEOUT))
events = await client.get_events_of([id_filter], source)
events = await client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
else:
if str(event_id).startswith('note'):
event_id = EventId.from_bech32(event_id)
@ -33,9 +32,7 @@ async def get_event_by_id(event_id: str, client: Client, config=None) -> Event |
id_filter = Filter().id(event_id).limit(1)
#events = client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
source = EventSource.relays(timedelta(seconds=5))
events = await client.get_events_of([id_filter], source)
events = await client.get_events_of([id_filter], timedelta(seconds=5))
if len(events) > 0:
@ -46,8 +43,7 @@ async def get_event_by_id(event_id: str, client: Client, config=None) -> Event |
return None
async def get_events_async(client, filter, timeout):
source = EventSource.relays(timedelta(seconds=timeout))
events = await client.get_events_of([filter], source)
events = await client.get_events_of([filter], timedelta(seconds=timeout))
return events
@ -59,8 +55,7 @@ async def get_events_by_ids(event_ids, client: Client, config=None) -> List | No
if len(split) == 3:
pk = PublicKey.from_hex(split[1])
id_filter = Filter().author(pk).custom_tag(SingleLetterTag.lowercase(Alphabet.D), [split[2]])
source = EventSource.relays(timedelta(seconds=config.RELAY_TIMEOUT))
events = await client.get_events_of([id_filter], source)
events = await client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
#events = client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
else:
if str(event_id).startswith('note'):
@ -77,8 +72,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)
source = EventSource.relays(timedelta(seconds=config.RELAY_TIMEOUT))
events = await client.get_events_of([id_filter], source)
events = await client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
#events = client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
if len(events) > 0:
@ -90,8 +84,7 @@ 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))
source = EventSource.relays(timedelta(seconds=config.RELAY_TIMEOUT))
events = await client.get_events_of([id_filter], source)
events = await client.get_events_of([id_filter], timedelta(seconds=config.RELAY_TIMEOUT))
if len(events) > 0:
return events
else:
@ -116,8 +109,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)
source = EventSource.relays(timedelta(seconds=dvm_config.RELAY_TIMEOUT))
events = await client.get_events_of([job_id_filter], source)
events = await client.get_events_of([job_id_filter], timedelta(seconds=dvm_config.RELAY_TIMEOUT))
#events = await get_events_async(client, job_id_filter, dvm_config.RELAY_TIMEOUT)
#events = client.get_events_of([job_id_filter], timedelta(seconds=dvm_config.RELAY_TIMEOUT))
@ -135,8 +127,7 @@ async def get_inbox_relays(event_to_send: Event, client: Client, dvm_config):
ptags.append(ptag)
filter = Filter().kinds([EventDefinitions.KIND_RELAY_ANNOUNCEMENT]).authors(ptags)
source = EventSource.relays(timedelta(seconds=dvm_config.RELAY_TIMEOUT))
events = await client.get_events_of([filter], source)
events = await client.get_events_of([filter], timedelta(dvm_config.RELAY_TIMEOUT))
if len(events) == 0:
return []
else:

11
nostr_dvm/utils/nut_wallet_utils.py
View File

@ -11,7 +11,7 @@ from nostr_dvm.utils.dvmconfig import DVMConfig
from nostr_dvm.utils.nostr_utils import check_and_set_private_key
from nostr_dvm.utils.zap_utils import pay_bolt11_ln_bits, zaprequest
from nostr_sdk import Tag, Keys, nip44_encrypt, nip44_decrypt, Nip44Version, EventBuilder, Client, Filter, Kind, \
EventId, nip04_decrypt, nip04_encrypt, Options, NostrSigner, PublicKey, init_logger, LogLevel, Metadata, EventSource
EventId, nip04_decrypt, nip04_encrypt, Options, NostrSigner, PublicKey, init_logger, LogLevel, Metadata
from nostr_dvm.utils.print import bcolors
class NutWallet(object):
@ -120,8 +120,7 @@ class NutZapWallet:
nut_wallet = None
wallet_filter = Filter().kind(EventDefinitions.KIND_NUT_WALLET).author(keys.public_key())
source = EventSource.relays(timedelta(seconds=10))
wallets = await client.get_events_of([wallet_filter], source)
wallets = await client.get_events_of([wallet_filter], timedelta(10))
if len(wallets) > 0:
@ -195,8 +194,7 @@ class NutZapWallet:
# Now all proof events
proof_filter = Filter().kind(Kind(7375)).author(keys.public_key())
source = EventSource.relays(timedelta(seconds=5))
proof_events = await client.get_events_of([proof_filter], source)
proof_events = await client.get_events_of([proof_filter], timedelta(5))
latest_proof_sec = 0
latest_proof_event_id = EventId
@ -449,8 +447,7 @@ class NutZapWallet:
async def fetch_mint_info_event(self, pubkey, client):
mint_info_filter = Filter().kind(Kind(10019)).author(PublicKey.parse(pubkey))
source = EventSource.relays(timedelta(seconds=5))
preferences = await client.get_events_of([mint_info_filter], source)
preferences = await client.get_events_of([mint_info_filter], timedelta(5))
mints = []
relays = []
pubkey = ""

9
nostr_dvm/utils/wot_utils.py
View File

@ -16,8 +16,7 @@ import random
from scipy.sparse import lil_matrix, csr_matrix, isspmatrix_csr
from nostr_sdk import Options, Keys, NostrSigner, NostrDatabase, ClientBuilder, SecretKey, Kind, PublicKey, Filter, \
EventSource
from nostr_sdk import Options, Keys, NostrSigner, NostrDatabase, ClientBuilder, SecretKey, Kind, PublicKey, Filter
from nostr_dvm.utils.dvmconfig import DVMConfig
from nostr_dvm.utils.nostr_utils import check_and_set_private_key
@ -61,8 +60,7 @@ async def get_following(pks, max_time_request=10, newer_than_time=None):
await cli.connect()
source = EventSource.relays(datetime.timedelta(seconds=100))
events = await cli.get_events_of([filter], source)
events = await cli.get_events_of([filter], datetime.timedelta(seconds=max_time_request))
# initializing the graph structure
following = nx.DiGraph()
@ -600,8 +598,7 @@ async def get_metadata(npub):
await client.connect()
profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
source = EventSource.relays(datetime.timedelta(seconds=4))
events = await client.get_events_of([profile_filter], source)
events = await client.get_events_of([profile_filter], datetime.timedelta(seconds=4))
if len(events) > 0:
try:
profile = json.loads(events[0].content())

4
setup.py
View File

@ -1,6 +1,6 @@
from setuptools import setup, find_packages
VERSION = '0.8.3'
VERSION = '0.8.4'
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.34.0",
install_requires=["nostr-sdk==0.33.0",
"bech32==1.2.0",
"pycryptodome==3.20.0",
"yt-dlp==2024.5.27",

5
tests/ditto.py
View File

@ -3,7 +3,7 @@ import json
from datetime import timedelta
from nostr_sdk import Options, SecretKey, NostrSigner, Keys, Client, RelayOptions, Alphabet, SingleLetterTag, Filter, \
Kind, PublicKey, init_logger, LogLevel, Tag, EventSource
Kind, PublicKey, init_logger, LogLevel, Tag
from nostr_dvm.utils.nostr_utils import check_and_set_private_key
@ -29,8 +29,7 @@ async def main():
authors = [PublicKey.parse("db0e60d10b9555a39050c258d460c5c461f6d18f467aa9f62de1a728b8a891a4")]
notes_filter = Filter().authors(authors).custom_tag(SingleLetterTag.lowercase(Alphabet.L), ltags)
source = EventSource.relays(timedelta(seconds=10))
events = await cli.get_events_of([notes_filter], source)
events = await cli.get_events_of([notes_filter], timedelta(seconds=10))
result_list = []
if len(events) > 0:

7
tests/gui/nicegui/nostrAI_search_client.py
View File

@ -4,7 +4,7 @@ import time
from datetime import timedelta
from nicegui import run, ui
from nostr_sdk import Keys, Client, Tag, EventBuilder, Filter, \
Options, Timestamp, NostrSigner, EventId, Nip19Event, PublicKey, EventSource
Options, Timestamp, NostrSigner, EventId, Nip19Event, PublicKey
from nostr_dvm.utils import dvmconfig
from nostr_dvm.utils.dvmconfig import DVMConfig
@ -65,9 +65,8 @@ async def init():
[EventDefinitions.KIND_FEEDBACK]).since(now).event(eventid)
lastfeedback = ""
while not response:
source = EventSource.relays(timedelta(seconds=3))
events = await client.get_events_of([feedbackfilter], source)
fevents = await client.get_events_of([feedbackfilter2], source)
events = await client.get_events_of([feedbackfilter], timedelta(seconds=3))
fevents = await client.get_events_of([feedbackfilter2], timedelta(seconds=3))
if len(fevents) > 0:
if lastfeedback != fevents[0].content():
for tag in fevents[0].tags():

8
tests/test_events.py
View File

@ -5,7 +5,7 @@ from pathlib import Path
import dotenv
from nostr_sdk import Keys, Client, Tag, EventBuilder, Filter, HandleNotification, Timestamp, nip04_decrypt, \
nip04_encrypt, EventId, Options, PublicKey, Event, NostrSigner, Nip19Event, SecretKey, Kind, EventSource
nip04_encrypt, EventId, Options, PublicKey, Event, NostrSigner, Nip19Event, SecretKey, Kind
from nostr_dvm.utils import definitions, dvmconfig
from nostr_dvm.utils.dvmconfig import DVMConfig
@ -61,8 +61,7 @@ async def test_referred_events(client, event_id, kinds=None):
else:
job_id_filter = Filter().event(EventId.from_hex(event_id))
source = EventSource.relays(timedelta(seconds=5))
events = await client.get_events_of([job_id_filter], source)
events = await client.get_events_of([job_id_filter], timedelta(seconds=5))
if len(events) > 0:
for event in events:
@ -142,8 +141,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)
source = EventSource.relays(timedelta(seconds=4))
events = await client.get_events_of([filterts], source)
events = await client.get_events_of([filterts], timedelta(seconds=5))
if len(events) > 0:
for event in events:

5
tests/wot.py
View File

@ -13,7 +13,7 @@ warnings.filterwarnings('ignore')
from nostr_sdk import RelayLimits, PublicKey, Options, Client, SecretKey, Keys, NostrSigner, RelayOptions, Filter, \
PublicKey, Kind, \
NegentropyOptions, NegentropyDirection, ClientBuilder, NostrDatabase, init_logger, LogLevel, EventSource
NegentropyOptions, NegentropyDirection, ClientBuilder, NostrDatabase, init_logger, LogLevel
# init_logger(LogLevel.INFO)
@ -35,8 +35,7 @@ async def getmetadata(npub):
await client.connect()
profile_filter = Filter().kind(Kind(0)).author(pk).limit(1)
source = EventSource.relays(timedelta(seconds=4))
events = await client.get_events_of([profile_filter], source)
events = await client.get_events_of([profile_filter], timedelta(seconds=4))
if len(events) > 0:
try:
profile = json.loads(events[0].content())