NSFW Show/Hide Results
NSFW Show/Hide Results
http") //.replace("\n", " ").replace(new RegExp(Regex_Url_Img, "gim"), "
8 |
25 |
26 |
9 |
10 |
11 |
12 |
22 |
13 | Search
14 | Discover
15 | Filter
16 | Create
17 | AI
18 | DVMs
19 |
20 |
21 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
37 |
38 |
42 |
45 |
46 |
47 |
48 |
--------------------------------------------------------------------------------
/tests/sunoai.py:
--------------------------------------------------------------------------------
1 | import asyncio
2 |
3 | import requests
4 |
5 | # replace your vercel domain
6 | base_url = 'http://localhost:3000'
7 |
8 |
9 | def custom_generate_audio(payload):
10 | url = f"{base_url}/api/custom_generate"
11 | response = requests.post(url, json=payload, headers={'Content-Type': 'application/json'})
12 | return response.json()
13 |
14 |
15 | def extend_audio(payload):
16 | url = f"{base_url}/api/extend_audio"
17 | response = requests.post(url, json=payload, headers={'Content-Type': 'application/json'})
18 | return response.json()
19 |
20 | def generate_audio_by_prompt(payload):
21 | url = f"{base_url}/api/generate"
22 | response = requests.post(url, json=payload, headers={'Content-Type': 'application/json'})
23 | return response.json()
24 |
25 |
26 | def get_audio_information(audio_ids):
27 | url = f"{base_url}/api/get?ids={audio_ids}"
28 | response = requests.get(url)
29 | return response.json()
30 |
31 |
32 | def get_quota_information():
33 | url = f"{base_url}/api/get_limit"
34 | response = requests.get(url)
35 | return response.json()
36 |
37 | def get_clip(clip_id):
38 | url = f"{base_url}/api/clip?id={clip_id}"
39 | response = requests.get(url)
40 | return response.json()
41 |
42 | def generate_whole_song(clip_id):
43 | payload = {"clip_id": clip_id}
44 | url = f"{base_url}/api/concat"
45 | response = requests.post(url, json=payload)
46 | return response.json()
47 |
48 |
49 | if __name__ == '__main__':
50 | prompt = "A popular heavy metal song about a purple Ostrich, Nostr, sung by a deep-voiced male singer, slowly and melodiously. The lyrics depict hope for a better future."
51 |
52 |
53 | has_quota = False
54 | quota_info = get_quota_information()
55 | if int(quota_info['credits_left']) >= 20:
56 | has_quota = True
57 | else:
58 | print("No quota left, exiting.")
59 |
60 |
61 | if has_quota:
62 |
63 | data = generate_audio_by_prompt({
64 | "prompt": prompt,
65 | "make_instrumental": False,
66 | "wait_audio": False
67 | })
68 | if len(data) == 0:
69 | print("Couldn't create song")
70 | pass
71 |
72 | ids = f"{data[0]['id']},{data[1]['id']}"
73 | print(f"ids: {ids}")
74 |
75 | for _ in range(60):
76 | data = get_audio_information(ids)
77 | if data[0]["status"] == 'streaming':
78 | print(f"{data[0]['id']} ==> {data[0]['video_url']}")
79 | print(f"{data[1]['id']} ==> {data[1]['video_url']}")
80 | break
81 | # sleep 5s
82 | asyncio.sleep(1.0)
83 |
84 | response1 = get_clip(data[0]['id'])
85 | print(response1['video_url'])
86 | print(response1['prompt'])
87 |
88 | response2 = get_clip(data[1]['id'])
89 | print(response2['video_url'])
90 | print(response2['prompt'])
91 |
92 |
93 |
94 |
95 |
--------------------------------------------------------------------------------
/tests/dalle.py:
--------------------------------------------------------------------------------
1 | import json
2 | import json
3 | import os
4 | from pathlib import Path
5 |
6 | import dotenv
7 | from nostr_sdk import LogLevel, init_logger
8 |
9 | from nostr_dvm.tasks.imagegeneration_openai_dalle import ImageGenerationDALLE
10 | from nostr_dvm.utils.admin_utils import AdminConfig
11 | from nostr_dvm.utils.dvmconfig import build_default_config
12 | from nostr_dvm.utils.nip89_utils import NIP89Config, check_and_set_d_tag
13 | from nostr_dvm.utils.zap_utils import get_price_per_sat
14 |
15 | rebroadcast_NIP89 = False # Announce NIP89 on startup Only do this if you know what you're doing.
16 | rebroadcast_NIP65_Relay_List = False
17 | update_profile = False
18 |
19 | use_logger = True
20 | log_level = LogLevel.ERROR
21 |
22 | if use_logger:
23 | init_logger(log_level)
24 |
25 |
26 | def build_dalle(name, identifier):
27 | dvm_config = build_default_config(identifier)
28 |
29 | dvm_config.NEW_USER_BALANCE = 0
30 | dvm_config.USE_OWN_VENV = False
31 | dvm_config.ENABLE_NUTZAP = True
32 | profit_in_sats = 10
33 | dvm_config.FIX_COST = int(((4.0 / (get_price_per_sat("USD") * 100)) + profit_in_sats))
34 | nip89info = {
35 | "name": name,
36 | "picture": "https://image.nostr.build/22f2267ca9d4ee9d5e8a0c7818a9fa325bbbcdac5573a60a2d163e699bb69923.jpg",
37 | "about": "I create Images bridging OpenAI's DALL·E 3",
38 | "supportsEncryption": True,
39 | "acceptsNutZaps": dvm_config.ENABLE_NUTZAP,
40 | "nip90Params": {
41 | "size": {
42 | "required": False,
43 | "values": ["1024:1024", "1024x1792", "1792x1024"]
44 | }
45 | }
46 | }
47 | nip89config = NIP89Config()
48 | nip89config.DTAG = check_and_set_d_tag(identifier, name, dvm_config.PRIVATE_KEY,
49 | nip89info["picture"])
50 | nip89config.CONTENT = json.dumps(nip89info)
51 | aconfig = AdminConfig()
52 | aconfig.REBROADCAST_NIP89 = False # We add an optional AdminConfig for this one, and tell the dvm to rebroadcast its NIP89
53 | aconfig.LUD16 = dvm_config.LN_ADDRESS
54 | aconfig.PRIVKEY = dvm_config.PRIVATE_KEY
55 | aconfig.MELT_ON_STARTUP = False # set this to true to melt cashu tokens to our ln address on startup
56 | return ImageGenerationDALLE(name=name, dvm_config=dvm_config, nip89config=nip89config, admin_config=aconfig)
57 |
58 |
59 | def playground():
60 | if os.getenv("OPENAI_API_KEY") is not None and os.getenv("OPENAI_API_KEY") != "":
61 | dalle = build_dalle("Dall-E 3", "dalle3")
62 | dalle.run(True)
63 |
64 |
65 | if __name__ == '__main__':
66 | env_path = Path('.env')
67 | if not env_path.is_file():
68 | with open('.env', 'w') as f:
69 | print("Writing new .env file")
70 | f.write('')
71 | if env_path.is_file():
72 | print(f'loading environment from {env_path.resolve()}')
73 | dotenv.load_dotenv(env_path, verbose=True, override=True)
74 | else:
75 | raise FileNotFoundError(f'.env file not found at {env_path} ')
76 | playground()
77 |
--------------------------------------------------------------------------------
/nostr_dvm/backends/mcp/messages/send_initialize_message.py:
--------------------------------------------------------------------------------
1 | # messages/send_initialize_message.py
2 | import logging
3 | import anyio
4 | from typing import Optional
5 | from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
6 |
7 | from nostr_dvm.backends.mcp.messages.message_types.initialize_message import (
8 | InitializeMessage,
9 | InitializedNotificationMessage,
10 | InitializeParams,
11 | MCPClientCapabilities,
12 | MCPClientInfo,
13 | InitializeResult,
14 | )
15 |
16 |
17 | async def send_initialize(
18 | read_stream: MemoryObjectReceiveStream,
19 | write_stream: MemoryObjectSendStream,
20 | ) -> Optional[InitializeResult]:
21 | """Send an initialization request to the server and process its response."""
22 |
23 | # Set initialize params
24 | init_params = InitializeParams(
25 | protocolVersion="2024-11-05",
26 | capabilities=MCPClientCapabilities(),
27 | clientInfo=MCPClientInfo(),
28 | )
29 |
30 | # Create the initialize message
31 | init_message = InitializeMessage(init_params)
32 |
33 | # Sending
34 | logging.debug("Sending initialize request")
35 | await write_stream.send(init_message)
36 |
37 | try:
38 | # 5-second timeout for response
39 | with anyio.fail_after(5):
40 | # Get the response from the server
41 | async for response in read_stream:
42 | # If the response is an exception, log it and continue
43 | if isinstance(response, Exception):
44 | logging.error(f"Error from server: {response}")
45 | continue
46 |
47 | # Debug log the received message
48 | logging.debug(f"Received: {response.model_dump()}")
49 |
50 | # Check for error
51 | if response.error:
52 | logging.error(f"Server initialization error: {response.error}")
53 | return None
54 |
55 | # Check for result
56 | if response.result:
57 | try:
58 | # Validate the result
59 | init_result = InitializeResult.model_validate(response.result)
60 | logging.debug("Server initialized successfully")
61 |
62 | # Notify the server of successful initialization
63 | initialized_notify = InitializedNotificationMessage()
64 | await write_stream.send(initialized_notify)
65 |
66 | return init_result
67 | except Exception as e:
68 | logging.error(f"Error processing init result: {e}")
69 | return None
70 |
71 | except TimeoutError:
72 | logging.error("Timeout waiting for server initialization response")
73 | return None
74 | except Exception as e:
75 | logging.error(f"Unexpected error during server initialization: {e}")
76 | raise
77 |
78 | # Timeout
79 | logging.error("Initialization response timeout")
80 | return None
81 |
--------------------------------------------------------------------------------
/nostr_dvm/utils/external_dvm_utils.py:
--------------------------------------------------------------------------------
1 | import asyncio
2 | import json
3 | from datetime import timedelta
4 |
5 | from nostr_sdk import PublicKey, Options, Keys, Client, NostrSigner
6 |
7 | from nostr_dvm.interfaces.dvmtaskinterface import DVMTaskInterface
8 | from nostr_dvm.utils.dvmconfig import DVMConfig
9 | from nostr_dvm.utils.nip89_utils import NIP89Config, nip89_fetch_events_pubkey
10 | from nostr_dvm.utils.output_utils import PostProcessFunctionType
11 |
12 |
13 | async def build_client(config):
14 | keys = Keys.parse(config.PRIVATE_KEY)
15 | client = Client(NostrSigner.keys(keys))
16 |
17 | for relay in config.RELAY_LIST:
18 | await client.add_relay(relay)
19 | await client.connect()
20 | return client
21 |
22 |
23 | def build_external_dvm(pubkey, task, kind, fix_cost, per_unit_cost, config,
24 | external_post_process=PostProcessFunctionType.NONE):
25 | pubkey = PublicKey.parse(pubkey).to_hex()
26 | dvm_config = DVMConfig()
27 | dvm_config.PUBLIC_KEY = pubkey
28 | dvm_config.FIX_COST = fix_cost
29 | dvm_config.PER_UNIT_COST = per_unit_cost
30 | dvm_config.EXTERNAL_POST_PROCESS_TYPE = external_post_process
31 |
32 | client = asyncio.run(build_client(config))
33 |
34 | nip89content_str = asyncio.run(nip89_fetch_events_pubkey(client, pubkey, kind))
35 | name = "External DVM"
36 | image = "https://image.nostr.build/c33ca6fc4cc038ca4adb46fdfdfda34951656f87ee364ef59095bae1495ce669.jpg"
37 | about = "An External DVM with no info"
38 | nip90params = {}
39 | encryption_supported = False
40 | cashu_accepted = False
41 |
42 | if nip89content_str is not None:
43 | print(nip89content_str)
44 | nip89content = json.loads(nip89content_str)
45 | if nip89content.get("name"):
46 | name = nip89content.get("name")
47 | if nip89content.get("picture"):
48 | image = nip89content.get("picture")
49 | elif nip89content.get("image"):
50 | image = nip89content.get("image")
51 | if nip89content.get("about"):
52 | about = nip89content.get("about")
53 | if nip89content.get("nip90Params"):
54 | nip90params = nip89content["nip90Params"]
55 | if nip89content.get("supportsEncryption"):
56 | encryption_supported = nip89content["supportsEncryption"]
57 | if nip89content.get("acceptsNutZaps"):
58 | cashu_accepted = nip89content["acceptsNutZaps"]
59 | else:
60 | print("No NIP89 set for " + name)
61 | nip89info = {
62 | "name": name,
63 | "picture": image,
64 | "about": about,
65 | "supportsEncryption": encryption_supported,
66 | "acceptsNutZaps": cashu_accepted,
67 | "nip90Params": nip90params
68 | }
69 | nip89config = NIP89Config()
70 | nip89config.KIND = kind
71 | nip89config.CONTENT = json.dumps(nip89info)
72 |
73 | interface = DVMTaskInterface(name=name, dvm_config=dvm_config, nip89config=nip89config, task=task)
74 | interface.SUPPORTS_ENCRYPTION = encryption_supported
75 | interface.ACCEPTS_CASHU = cashu_accepted
76 |
77 | return interface
78 |
--------------------------------------------------------------------------------
/nostr_dvm/utils/blossom_utils.py:
--------------------------------------------------------------------------------
1 | import base64
2 | import hashlib
3 | import json
4 | import mimetypes
5 | import os
6 |
7 | import aiohttp
8 | from nostr_sdk import Keys, Tag, EventBuilder, Kind, Timestamp
9 |
10 |
11 | def sha256(file):
12 | h = hashlib.sha256()
13 | h.update(file)
14 | return h.digest().hex()
15 |
16 | async def check(url, sha256, key):
17 | async with aiohttp.ClientSession(url) as sess:
18 | b64_auth = await generate_blossom_header(key, sha256, "get")
19 | headers = {
20 | "Authorization": b64_auth
21 | }
22 |
23 | async with sess.get(f"{sha256}", headers=headers) as resp:
24 | return resp.status == 200
25 |
26 |
27 | async def generate_blossom_header(key, hash, method):
28 |
29 | keys = Keys.parse(key)
30 | t_tag = Tag.parse(["t", method])
31 | x_tag = Tag.parse(["x", hash])
32 | expiration_tag = Tag.parse(["expiration", str(Timestamp.now().as_secs() + 300)])
33 | tags = [x_tag, t_tag, expiration_tag]
34 |
35 | eb = EventBuilder(Kind(24242), "Uploading blob with SHA-256 hash").tags(tags)
36 | event = eb.sign_with_keys(keys)
37 |
38 | encoded_nip98_event = base64.b64encode(event.as_json().encode('utf-8')).decode('utf-8')
39 | return "Nostr " + encoded_nip98_event
40 |
41 |
42 | def upload_image_to_blossom(file_path, url):
43 | """Uploads an image to a Blossom server via a PUT request."""
44 |
45 |
46 | async def upload_blossom(filepath, pkey, url):
47 |
48 | with open(filepath, "rb") as f:
49 | mtime = int(os.fstat(f.fileno()).st_mtime)
50 |
51 | file = f.read()
52 | hash = sha256(file)
53 | b64_auth = await generate_blossom_header(pkey, hash, "upload")
54 |
55 | file_stats = os.stat(filepath)
56 | sizeinmb = file_stats.st_size / (1024 * 1024)
57 | print("Filesize of Uploaded media: " + str(sizeinmb) + " Mb.")
58 |
59 | if await check(url, hash, pkey):
60 | print(f"Blob {hash} is up to date for [{filepath}].")
61 | else:
62 | print(f"Storing file [{hash}] on blossom.")
63 |
64 |
65 | content_type = mimetypes.guess_type(filepath)[0] or 'application/octet-stream'
66 |
67 | # Upload object to blossom.
68 | async with aiohttp.ClientSession() as sess:
69 | async with sess.put(
70 | url = url.rstrip('/') + '/upload',
71 | data=file,
72 | headers={
73 | "Authorization": b64_auth,
74 | "Content-Type": content_type
75 | }) as resp:
76 |
77 |
78 | if resp.status == 413:
79 | print("Can't upload on Blossom Server")
80 | return "Can't upload on Blossom Server"
81 |
82 | elif resp.status != 200:
83 | txt = await resp.text()
84 | print(txt)
85 | else:
86 | res = await resp.text()
87 | resjson = json.loads(res)
88 | print(resjson["url"])
89 | return resjson["url"]
90 |
91 |
--------------------------------------------------------------------------------
/tests/sd35_api.py:
--------------------------------------------------------------------------------
1 | import json
2 | import os
3 | from pathlib import Path
4 |
5 | import dotenv
6 | from nostr_sdk import LogLevel, init_logger
7 |
8 | from nostr_dvm.tasks.imagegeneration_sd35_api import ImageGenerationSD35
9 | from nostr_dvm.utils.admin_utils import AdminConfig
10 | from nostr_dvm.utils.dvmconfig import build_default_config
11 | from nostr_dvm.utils.nip89_utils import NIP89Config, check_and_set_d_tag
12 | from nostr_dvm.utils.zap_utils import get_price_per_sat
13 |
14 | rebroadcast_NIP89 = False # Announce NIP89 on startup Only do this if you know what you're doing.
15 | rebroadcast_NIP65_Relay_List = False
16 | update_profile = False
17 |
18 | use_logger = True
19 | log_level = LogLevel.ERROR
20 |
21 | if use_logger:
22 | init_logger(log_level)
23 |
24 |
25 | def build_sd35(name, identifier):
26 | dvm_config = build_default_config(identifier)
27 |
28 | dvm_config.NEW_USER_BALANCE = 0
29 | dvm_config.USE_OWN_VENV = False
30 | dvm_config.ENABLE_NUTZAP = True
31 | profit_in_sats = 10
32 | dvm_config.FIX_COST = int(((4.0 / (get_price_per_sat("USD") * 100)) + profit_in_sats))
33 | nip89info = {
34 | "name": name,
35 | "picture": "https://i.nostr.build/NOXcCIPmOZrDTK35.jpg",
36 | "about": "I draw images using Stable diffusion ultra",
37 | "supportsEncryption": True,
38 | "acceptsNutZaps": dvm_config.ENABLE_NUTZAP,
39 | "nip90Params": {
40 | "negative_prompt": {
41 | "required": False,
42 | "values": []
43 | },
44 | "ratio": {
45 | "required": False,
46 | "values": ["1:1", "5:4", "3:2", "16:9","21:9", "9:21", "9:16", "2:3", "4:5"]
47 | }
48 | }
49 | }
50 | nip89config = NIP89Config()
51 | nip89config.DTAG = check_and_set_d_tag(identifier, name, dvm_config.PRIVATE_KEY,
52 | nip89info["picture"])
53 | nip89config.CONTENT = json.dumps(nip89info)
54 | aconfig = AdminConfig()
55 | aconfig.REBROADCAST_NIP89 = False # We add an optional AdminConfig for this one, and tell the dvm to rebroadcast its NIP89
56 | aconfig.LUD16 = dvm_config.LN_ADDRESS
57 | aconfig.PRIVKEY = dvm_config.PRIVATE_KEY
58 | aconfig.MELT_ON_STARTUP = False # set this to true to melt cashu tokens to our ln address on startup
59 |
60 |
61 | options= {"API_KEY": os.getenv("STABILITY_KEY")}
62 |
63 |
64 | return ImageGenerationSD35(name=name, dvm_config=dvm_config, nip89config=nip89config, admin_config=aconfig, options=options)
65 |
66 |
67 | def playground():
68 | if os.getenv("STABILITY_KEY") is not None and os.getenv("STABILITY_KEY") != "":
69 | sd35 = build_sd35("Stable Diffusion 3.5", "sd35")
70 | sd35.run(True)
71 |
72 |
73 | if __name__ == '__main__':
74 | env_path = Path('.env')
75 | if not env_path.is_file():
76 | with open('.env', 'w') as f:
77 | print("Writing new .env file")
78 | f.write('')
79 | if env_path.is_file():
80 | print(f'loading environment from {env_path.resolve()}')
81 | dotenv.load_dotenv(env_path, verbose=True, override=True)
82 | else:
83 | raise FileNotFoundError(f'.env file not found at {env_path} ')
84 | playground()
85 |
--------------------------------------------------------------------------------
/tests/fix_lnbits_lnaddress.py:
--------------------------------------------------------------------------------
1 | import os
2 | from pathlib import Path
3 | import dotenv
4 | from nostr_dvm.utils.zap_utils import make_ln_address_nostdress, create_lnbits_wallet, add_key_to_env_file
5 |
6 |
7 | def playground():
8 | # change the idenftier to the dvm you want to update.
9 | # This will create a new lnbits wallet and update the lnaddress to it
10 | # This is for existing dvms
11 | identifier = "discovery_content_gm"
12 | check_and_set_ln_bits_keys_force_new(identifier, os.getenv("DVM_PRIVATE_KEY_BOT_" + identifier.upper()))
13 |
14 |
15 |
16 | def check_and_set_ln_bits_keys(identifier, npub):
17 | if not os.getenv("LNBITS_INVOICE_KEY_" + identifier.upper()):
18 | invoicekey, adminkey, walletid, success = create_lnbits_wallet(identifier)
19 |
20 | add_key_to_env_file("LNBITS_INVOICE_KEY_" + identifier.upper(), invoicekey)
21 | add_key_to_env_file("LNBITS_ADMIN_KEY_" + identifier.upper(), adminkey)
22 | add_key_to_env_file("LNBITS_WALLET_ID_" + identifier.upper(), walletid)
23 |
24 | lnaddress = ""
25 | pin = ""
26 | if os.getenv("NOSTDRESS_DOMAIN") and success != "failed":
27 | print(os.getenv("NOSTDRESS_DOMAIN"))
28 | lnaddress, pin = make_ln_address_nostdress(identifier, npub, " ", os.getenv("NOSTDRESS_DOMAIN"), identifier)
29 | add_key_to_env_file("LNADDRESS_" + identifier.upper(), lnaddress)
30 | add_key_to_env_file("LNADDRESS_PIN_" + identifier.upper(), pin)
31 |
32 | return invoicekey, adminkey, walletid, lnaddress
33 | else:
34 | return (os.getenv("LNBITS_INVOICE_KEY_" + identifier.upper()),
35 | os.getenv("LNBITS_ADMIN_KEY_" + identifier.upper()),
36 | os.getenv("LNBITS_WALLET_ID_" + identifier.upper()),
37 | os.getenv("LNADDRESS_" + identifier.upper()))
38 |
39 |
40 |
41 | def check_and_set_ln_bits_keys_force_new(identifier, npub):
42 | #FORCE UPDATE THE CONFIG; INSTALL NEW WALLET
43 | invoicekey, adminkey, walletid, success = create_lnbits_wallet(identifier)
44 |
45 | add_key_to_env_file("LNBITS_INVOICE_KEY_" + identifier.upper(), invoicekey)
46 | add_key_to_env_file("LNBITS_ADMIN_KEY_" + identifier.upper(), adminkey)
47 | add_key_to_env_file("LNBITS_WALLET_ID_" + identifier.upper(), walletid)
48 |
49 | lnaddress = ""
50 | if os.getenv("NOSTDRESS_DOMAIN") and success != "failed":
51 | print(os.getenv("NOSTDRESS_DOMAIN"))
52 | lnaddress, pin = make_ln_address_nostdress(identifier, npub, os.getenv("LNADDRESS_PIN_" + identifier.upper()), os.getenv("NOSTDRESS_DOMAIN"), identifier)
53 | add_key_to_env_file("LNADDRESS_" + identifier.upper(), lnaddress)
54 | add_key_to_env_file("LNADDRESS_PIN_" + identifier.upper(), pin)
55 |
56 | return invoicekey, adminkey, walletid, lnaddress
57 |
58 |
59 |
60 | if __name__ == '__main__':
61 | env_path = Path('.env')
62 | if not env_path.is_file():
63 | with open('.env', 'w') as f:
64 | print("Writing new .env file")
65 | f.write('')
66 | if env_path.is_file():
67 | print(f'loading environment from {env_path.resolve()}')
68 | dotenv.load_dotenv(env_path, verbose=True, override=True)
69 | else:
70 | raise FileNotFoundError(f'.env file not found at {env_path} ')
71 | playground()
72 |
--------------------------------------------------------------------------------
/tutorials/10_delete_nip89.py:
--------------------------------------------------------------------------------
1 |
2 | # Welcome Back. So you were playing around with a DVM and announced it to the world, but now you rather would like
3 | # to remove it, because you don't want to run it anymore or you did it by accident. In this tutorial we look at how to
4 | # remove NIP89 announcements, so our DVM doesn't appear in clients anymore.
5 | # Check the main function for more instructions.
6 |
7 |
8 |
9 | import asyncio
10 | from datetime import timedelta
11 |
12 | from nostr_sdk import Keys, Client, NostrSigner, Filter
13 |
14 | from nostr_dvm.utils.definitions import EventDefinitions
15 | from nostr_dvm.utils.dvmconfig import DVMConfig
16 | from nostr_dvm.utils.nip89_utils import fetch_nip89_parameters_for_deletion
17 |
18 | # Method to delete the NIP89, don't worry, you don't have to touch this, take a look in the main function.
19 | async def delete_nip_89(private_key, relay_list, pow=True):
20 | keys = Keys.parse(private_key)
21 | dvm_config = DVMConfig()
22 | dvm_config.RELAY_LIST = relay_list
23 | client = Client(NostrSigner.keys(keys))
24 | for relay in dvm_config.RELAY_LIST:
25 | await client.add_relay(relay)
26 | await client.connect()
27 | filter = Filter().kind(EventDefinitions.KIND_ANNOUNCEMENT).author(keys.public_key())
28 | events = await client.fetch_events(filter, timedelta(seconds=5))
29 |
30 | if len(events.to_vec()) == 0:
31 | print("Couldn't find note on relays. Seems they are gone.")
32 | return
33 |
34 | for event in events.to_vec():
35 | print(event)
36 | await fetch_nip89_parameters_for_deletion(keys, event.id().to_hex(), client, dvm_config, pow)
37 |
38 |
39 |
40 | if __name__ == '__main__':
41 |
42 | # What do you need to delete an event?
43 |
44 | # The first thing you need is the private key of the DVM the announcement was made for.
45 | # NostrDVM stores all your keys in the .env file. Open the .env file and search for
46 | # DVM_PRIVATE_KEY_{IDENTIFIER_OF_YOUR_DVM}. Enter it below in the field private_key:
47 |
48 | private_key = "83274234123..."
49 |
50 | # You can either use Proof of Work to send the delete event or not. Some relays require you to use POW in order to write.
51 | # Sending a POW event might take up to a couple of minutes, so if you decide to use it, have some patience in the progress.
52 | # If you know the relays you published your announcements to do not require POW, you can also set it to False which speeds up the progress.
53 | pow = False
54 |
55 | # And finally set the relay list you want to send the deletion request to. Ideally, you use the same relays that you use
56 | # in your DVM's config. Maybe announcements also got propagated to other relays, so you might need to play around a bit until it's gone everywhere.
57 | RELAY_LIST = ["wss://relay.primal.net",
58 | "wss://relay.damus.io",
59 | "wss://relay.nostrplebs.com",
60 | "wss://promenade.fiatjaf.com",
61 | "wss://nostr.mom",
62 | "wss://nostr.oxtr.dev",
63 | "wss://relay.nostr.band"
64 | ]
65 |
66 | # That's it. Once you entered the info, run the script and if your private key matches the ID and the event can be found it should be deleted.
67 | # Otherwise you'll get a warning
68 | asyncio.run(delete_nip_89(private_key, RELAY_LIST, pow))
--------------------------------------------------------------------------------
/nostr_dvm/backends/mlx/modules/stable_diffusion/__init__.py:
--------------------------------------------------------------------------------
1 | # Copyright © 2023 Apple Inc.
2 |
3 | import time
4 | from typing import Tuple
5 |
6 | import mlx.core as mx
7 |
8 | from .model_io import (
9 | _DEFAULT_MODEL,
10 | load_autoencoder,
11 | load_diffusion_config,
12 | load_text_encoder,
13 | load_tokenizer,
14 | load_unet,
15 | )
16 | from .sampler import SimpleEulerSampler
17 |
18 |
19 | def _repeat(x, n, axis):
20 | # Make the expanded shape
21 | s = x.shape
22 | s.insert(axis + 1, n)
23 |
24 | # Expand
25 | x = mx.broadcast_to(mx.expand_dims(x, axis + 1), s)
26 |
27 | # Make the flattened shape
28 | s.pop(axis + 1)
29 | s[axis] *= n
30 |
31 | return x.reshape(s)
32 |
33 |
34 | class StableDiffusion:
35 | def __init__(self, model: str = _DEFAULT_MODEL, float16: bool = False):
36 | self.dtype = mx.float16 if float16 else mx.float32
37 | self.diffusion_config = load_diffusion_config(model)
38 | self.unet = load_unet(model, float16)
39 | self.text_encoder = load_text_encoder(model, float16)
40 | self.autoencoder = load_autoencoder(model, float16)
41 | self.sampler = SimpleEulerSampler(self.diffusion_config)
42 | self.tokenizer = load_tokenizer(model)
43 |
44 | def generate_latents(
45 | self,
46 | text: str,
47 | n_images: int = 1,
48 | num_steps: int = 50,
49 | cfg_weight: float = 7.5,
50 | negative_text: str = "",
51 | latent_size: Tuple[int] = (64, 64),
52 | seed=None,
53 | ):
54 | # Set the PRNG state
55 | seed = seed or int(time.time())
56 | mx.random.seed(seed)
57 |
58 | # Tokenize the text
59 | tokens = [self.tokenizer.tokenize(text)]
60 | if cfg_weight > 1:
61 | tokens += [self.tokenizer.tokenize(negative_text)]
62 | lengths = [len(t) for t in tokens]
63 | N = max(lengths)
64 | tokens = [t + [0] * (N - len(t)) for t in tokens]
65 | tokens = mx.array(tokens)
66 |
67 | # Compute the features
68 | conditioning = self.text_encoder(tokens)
69 |
70 | # Repeat the conditioning for each of the generated images
71 | if n_images > 1:
72 | conditioning = _repeat(conditioning, n_images, axis=0)
73 |
74 | # Create the latent variables
75 | x_T = self.sampler.sample_prior(
76 | (n_images, *latent_size, self.autoencoder.latent_channels), dtype=self.dtype
77 | )
78 |
79 | # Perform the denoising loop
80 | x_t = x_T
81 | for t, t_prev in self.sampler.timesteps(num_steps, dtype=self.dtype):
82 | x_t_unet = mx.concatenate([x_t] * 2, axis=0) if cfg_weight > 1 else x_t
83 | t_unet = mx.broadcast_to(t, [len(x_t_unet)])
84 | eps_pred = self.unet(x_t_unet, t_unet, encoder_x=conditioning)
85 |
86 | if cfg_weight > 1:
87 | eps_text, eps_neg = eps_pred.split(2)
88 | eps_pred = eps_neg + cfg_weight * (eps_text - eps_neg)
89 |
90 | x_t_prev = self.sampler.step(eps_pred, x_t, t, t_prev)
91 | x_t = x_t_prev
92 | yield x_t
93 |
94 | def decode(self, x_t):
95 | x = self.autoencoder.decode(x_t / self.autoencoder.scaling_factor)
96 | x = mx.minimum(1, mx.maximum(0, x / 2 + 0.5))
97 | return x
98 |
--------------------------------------------------------------------------------
/nostr_dvm/backends/mcp/transport/stdio/stdio_server_shutdown.py:
--------------------------------------------------------------------------------
1 | # transport/stdio/stdio_server_shutdown.py
2 | import logging
3 | from typing import Optional
4 |
5 | import anyio
6 | from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
7 |
8 |
9 | async def shutdown_stdio_server(
10 | read_stream: Optional[MemoryObjectReceiveStream],
11 | write_stream: Optional[MemoryObjectSendStream],
12 | process: anyio.abc.Process,
13 | timeout: float = 5.0,
14 | ) -> None:
15 | """
16 | Gracefully shutdown a stdio-based server.
17 |
18 | This function performs the following steps:
19 | 1. Closes the stdin stream of the process.
20 | 2. Waits for the process to terminate gracefully.
21 | 3. Sends SIGTERM if the process does not terminate within the timeout.
22 | 4. Sends SIGKILL if the process does not terminate after SIGTERM.
23 | 5. Logs each step and ensures cleanup in case of errors.
24 |
25 | Args:
26 | read_stream (Optional[MemoryObjectReceiveStream]): Stream to receive responses.
27 | write_stream (Optional[MemoryObjectSendStream]): Stream to send requests.
28 | process (anyio.abc.Process): The server process.
29 | timeout (float): Time to wait for graceful shutdown and SIGTERM before escalation.
30 | """
31 | logging.info("Initiating stdio server shutdown")
32 |
33 | try:
34 | # ensure we have a process
35 | if process:
36 | # Step 1: Close the write stream (stdin for the server)
37 | if process.stdin:
38 | # close
39 | await process.stdin.aclose()
40 | logging.info("Closed stdin stream")
41 |
42 | # Step 2: Wait for the process to terminate gracefully
43 | with anyio.fail_after(timeout):
44 | await process.wait()
45 | logging.info("Process exited normally")
46 | return
47 |
48 | except TimeoutError:
49 | logging.warning(
50 | f"Server did not exit within {timeout} seconds, sending SIGTERM"
51 | )
52 |
53 | # ensure we have a process
54 | if process:
55 | # terminate
56 | process.terminate()
57 |
58 | try:
59 | # Step 3: Wait for the process to terminate after SIGTERM
60 | with anyio.fail_after(timeout):
61 | await process.wait()
62 | logging.info("Process exited after SIGTERM")
63 | return
64 | except TimeoutError:
65 | logging.warning("Server did not respond to SIGTERM, sending SIGKILL")
66 |
67 | # ensure we have a process
68 | if process:
69 | # kill
70 | process.kill()
71 |
72 | # Step 4: Wait for the process to terminate after SIGKILL
73 | await process.wait()
74 | logging.info("Process exited after SIGKILL")
75 |
76 | except Exception as e:
77 | # Catch unexpected errors during shutdown
78 | logging.error(f"Unexpected error during stdio server shutdown: {e}")
79 |
80 | if process:
81 | # kill
82 | process.kill()
83 |
84 | # wait
85 | await process.wait()
86 | logging.info("Process forcibly terminated")
87 | finally:
88 | # complete
89 | logging.info("Stdio server shutdown complete")
90 |
--------------------------------------------------------------------------------
/nostr_dvm/backends/discover/modules/stablediffusionxl/stablediffusionxl-img2img.trainer:
--------------------------------------------------------------------------------
1 |
2 |