agentstr 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

agentstr/nostr.py

@@ -1,5 +1,11 @@
+import json
 import logging
-from typing import Optional
+import traceback
+from datetime import timedelta
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from agentstr.models import MerchantProduct, MerchantStall, NostrProfile
 
 try:
     import asyncio
@@ -10,11 +16,13 @@ except ImportError:
 
 try:
     from nostr_sdk import (
+        Alphabet,
         Client,
         Coordinate,
-        Event,
         EventBuilder,
         EventId,
+        Events,
+        Filter,
         Keys,
         Kind,
         Metadata,
@@ -23,8 +31,11 @@ try:
         PublicKey,
         ShippingCost,
         ShippingMethod,
+        SingleLetterTag,
         StallData,
         Tag,
+        TagKind,
+        TagStandard,
         Timestamp,
     )
 
@@ -44,8 +55,6 @@ class NostrClient:
     """
 
     logger = logging.getLogger("NostrClient")
-    ERROR: str = "ERROR"
-    SUCCESS: str = "SUCCESS"
 
     def __init__(
         self,
@@ -74,6 +83,7 @@ class NostrClient:
         self.keys = Keys.parse(nsec)
         self.nostr_signer = NostrSigner.keys(self.keys)
         self.client = Client(self.nostr_signer)
+        self.connected = False
 
     def delete_event(self, event_id: EventId, reason: Optional[str] = None) -> EventId:
         """
@@ -98,7 +108,7 @@ class NostrClient:
         Publish generic Nostr event to the relay
 
         Returns:
-            EventId: event id if successful or NostrClient.ERROR if unsuccesful
+            EventId: event id published
 
         Raises:
             RuntimeError: if the product can't be published
@@ -113,7 +123,7 @@ class NostrClient:
             text: text to be published as kind 1 event
 
         Returns:
-            EventId: EventId if successful or NostrClient.ERROR if unsuccesful
+            EventId: EventId if successful
 
         Raises:
             RuntimeError: if the product can't be published
@@ -121,7 +131,7 @@ class NostrClient:
         # Run the async publishing function synchronously
         return asyncio.run(self._async_publish_note(text))
 
-    def publish_product(self, product: ProductData) -> EventId:
+    def publish_product(self, product: MerchantProduct) -> EventId:
         """
         Create or update a NIP-15 Marketplace product with event kind 30018
 
@@ -129,13 +139,16 @@ class NostrClient:
             product: product to be published
 
         Returns:
-            EventId: event id if successful or NostrClient.ERROR if unsuccesful
+            EventId: event id of the publication event
 
         Raises:
             RuntimeError: if the product can't be published
         """
         # Run the async publishing function synchronously
-        return asyncio.run(self._async_publish_product(product))
+        try:
+            return asyncio.run(self._async_publish_product(product))
+        except Exception as e:
+            raise RuntimeError(f"Failed to publish product: {e}")
 
     def publish_profile(self, name: str, about: str, picture: str) -> EventId:
         """
@@ -147,7 +160,7 @@ class NostrClient:
             picture: url to a png file with a picture for the profile
 
         Returns:
-            EventId: event id if successful or NostrClient.ERROR if unsuccesful
+            EventId: event id if successful
 
         Raises:
             RuntimeError: if the profile can't be published
@@ -155,20 +168,166 @@ class NostrClient:
         # Run the async publishing function synchronously
         return asyncio.run(self._async_publish_profile(name, about, picture))
 
-    def publish_stall(self, stall: StallData) -> EventId:
+    def publish_stall(self, stall: MerchantStall) -> EventId:
         """Publish a stall to nostr
 
         Args:
             stall: stall to be published
 
         Returns:
-            EventId: event id if successful or NostrClient.ERROR if unsuccesful
+            EventId: Id of the publication event
+
+        Raises:
+            RuntimeError: if the stall can't be published
         """
         try:
             return asyncio.run(self._async_publish_stall(stall))
         except Exception as e:
-            self.logger.error(f"Failed to publish stall: {e}")
-            return NostrClient.ERROR
+            raise RuntimeError(f"Failed to publish stall: {e}")
+
+    def retrieve_products_from_seller(self, seller: PublicKey) -> List[MerchantProduct]:
+        """
+        Retrieve all products from a given seller.
+
+        Args:
+            seller: PublicKey of the seller
+
+        Returns:
+            List[MerchantProduct]: list of products from the seller
+        """
+        products = []
+        try:
+            events = asyncio.run(self._async_retrieve_products_from_seller(seller))
+            events_list = events.to_vec()
+            for event in events_list:
+                content = json.loads(event.content())
+                product_data = ProductData(
+                    id=content.get("id"),
+                    stall_id=content.get("stall_id"),
+                    name=content.get("name"),
+                    description=content.get("description"),
+                    images=content.get("images", []),
+                    currency=content.get("currency"),
+                    price=content.get("price"),
+                    quantity=content.get("quantity"),
+                    specs=content.get("specs", {}),
+                    shipping=content.get("shipping", []),
+                    categories=content.get("categories", []),
+                )
+                products.append(MerchantProduct.from_product_data(product_data))
+            return products
+        except Exception as e:
+            raise RuntimeError(f"Failed to retrieve products: {e}")
+
+    def retrieve_profile(self, public_key: PublicKey) -> NostrProfile:
+        """
+        Retrieve a Nostr profile from the relay.
+
+        Args:
+            public_key: bech32 encoded public key of the profile to retrieve
+
+        Returns:
+            NostrProfile: profile of the author
+
+        Raises:
+            RuntimeError: if the profile can't be retrieved
+        """
+        try:
+            return asyncio.run(self._async_retrieve_profile(public_key))
+        except Exception as e:
+            raise RuntimeError(f"Failed to retrieve profile: {e}")
+
+    def retrieve_sellers(self) -> set[NostrProfile]:
+        """
+        Retrieve all sellers from the relay.
+        Sellers are npubs who have published a stall.
+        Return set may be empty if metadata can't be retrieved for any author.
+
+        Returns:
+            set[NostrProfile]: set of seller profiles (skips authors with missing metadata)
+        """
+
+        sellers: set[NostrProfile] = set()
+
+        # First we retrieve all stalls from the relay
+
+        try:
+            events = asyncio.run(self._async_retrieve_all_stalls())
+        except Exception as e:
+            raise RuntimeError(f"Failed to retrieve stalls: {e}")
+
+        # Now we search for unique npubs from the list of stalls
+
+        events_list = events.to_vec()
+        authors: Dict[PublicKey, NostrProfile] = {}
+
+        for event in events_list:
+            if event.kind() == Kind(30017):
+                # Is this event the first time we see this author?
+                if event.author() not in authors:
+                    # First time we see this author. Let's add the profile to the dictionary
+                    try:
+                        profile = asyncio.run(
+                            self._async_retrieve_profile(event.author())
+                        )
+                        # Add the profile to the dictionary, associating it with the author's PublicKey
+                        authors[event.author()] = profile
+                    except Exception as e:
+                        # print(
+                        #     f"Failed to retrieve profile for {event.author().to_bech32()}: {e}"
+                        # )
+                        continue
+
+                # Now we add locations from the event locations to the profile
+
+                for tag in event.tags().to_vec():
+                    standardized_tag = tag.as_standardized()
+                    if isinstance(standardized_tag, TagStandard.GEOHASH):
+                        string_repr = str(standardized_tag)
+                        extracted_geohash = string_repr.split("=")[1].rstrip(
+                            ")"
+                        )  # Splitting and removing the closing parenthesis
+                        # print(
+                        #     f"Adding location {extracted_geohash} to profile {authors[event.author()].get_name()}"
+                        # )
+                        profile = authors[event.author()]
+                        profile.add_location(extracted_geohash)
+                        authors[event.author()] = profile
+                        # print(
+                        #     f"New locations for {authors[event.author()].get_name()}: {authors[event.author()].get_locations()}"
+                        # )
+                    # else:
+                    #     print(f"Unknown tag: {standardized_tag}")
+
+        # once we're done iterating over the events, we return the set of profiles
+        return set(authors.values())
+
+    def retrieve_stalls_from_seller(self, seller: PublicKey) -> List[StallData]:
+        """
+        Retrieve all stalls from a given seller.
+
+        Args:
+            seller: PublicKey of the seller
+
+        Returns:
+            List[StallData]: list of stalls from the seller
+        """
+        stalls = []
+        try:
+            events = asyncio.run(self._async_retrieve_stalls_from_seller(seller))
+            events_list = events.to_vec()
+            for event in events_list:
+                try:
+                    # Parse the content field instead of the whole event
+                    content = event.content()
+                    stall = StallData.from_json(content)
+                    stalls.append(stall)
+                except Exception as e:
+                    self.logger.warning(f"Failed to parse stall data: {e}")
+                    continue
+            return stalls
+        except Exception as e:
+            raise RuntimeError(f"Failed to retrieve stalls: {e}")
 
     @classmethod
     def set_logging_level(cls, logging_level: int) -> None:
@@ -186,23 +345,26 @@ class NostrClient:
     # --*-- async functions for internal use only. Developers should use synchronous functions above
     # ----------------------------------------------------------------------------------------------
 
-    async def _async_connect(self) -> str:
+    async def _async_connect(self) -> None:
         """Asynchronous function to add relay to the NostrClient instance and connect to it.
+        TBD: refactor to not return anything if successful and raise an exception if not
 
-        Returns:
-            str: NostrClient.SUCCESS or NostrClient.ERROR
+        Raises:
+            RuntimeError: if the relay can't be connected to
         """
-        try:
-            await self.client.add_relay(self.relay)
-            NostrClient.logger.info(f"Relay {self.relay} succesfully added.")
-            await self.client.connect()
-            NostrClient.logger.info("Connected to relay.")
-            return NostrClient.SUCCESS
-        except Exception as e:
-            NostrClient.logger.error(
-                f"Unable to connect to relay {self.relay}. Exception: {e}."
-            )
-            return NostrClient.ERROR
+
+        if not self.connected:
+            try:
+                await self.client.add_relay(self.relay)
+                NostrClient.logger.info(f"Relay {self.relay} succesfully added.")
+                await self.client.connect()
+                await asyncio.sleep(2)  # give time for slower connections
+                NostrClient.logger.info("Connected to relay.")
+                self.connected = True
+            except Exception as e:
+                raise RuntimeError(
+                    f"Unable to connect to relay {self.relay}. Exception: {e}."
+                )
 
     async def _async_publish_event(self, event_builder: EventBuilder) -> EventId:
         """
@@ -214,27 +376,35 @@ class NostrClient:
         Raises:
             RuntimeError: if the event can't be published
         """
-        connected = await self._async_connect()
+        try:
+            await self._async_connect()
 
-        if connected == NostrClient.ERROR:
-            raise RuntimeError("Unable to connect to the relay")
+            # Add debug logging
+            NostrClient.logger.debug(f"Attempting to publish event: {event_builder}")
+            NostrClient.logger.debug(
+                f"Using keys: {self.keys.public_key().to_bech32()}"
+            )
 
-        try:
+            # Wait for connection and try to publish
             output = await self.client.send_event_builder(event_builder)
-            if len(output.success) > 0:
-                NostrClient.logger.info(
-                    f"Event published with event id: {output.id.to_bech32()}"
+
+            # More detailed error handling
+            if not output:
+                raise RuntimeError("No output received from send_event_builder")
+            if len(output.success) == 0:
+                raise RuntimeError(
+                    f"Event rejected by relay. Reason: {output.message if hasattr(output, 'message') else 'unknown'}"
                 )
-                return output.id
-            else:
-                raise RuntimeError("Unable to publish event")
-        except Exception as e:
-            NostrClient.logger.error(
-                f"NostrClient instance not properly initialized. Exception: {e}."
-            )
-            raise RuntimeError(
-                f"NostrClient instance not properly initialized. Exception: {e}."
+
+            NostrClient.logger.info(
+                f"Event published with event id: {output.id.to_bech32()}"
             )
+            return output.id
+
+        except Exception as e:
+            NostrClient.logger.error(f"Failed to publish event: {str(e)}")
+            NostrClient.logger.debug("Event details:", exc_info=True)
+            raise RuntimeError(f"Unable to publish event: {str(e)}")
 
     async def _async_publish_note(self, text: str) -> EventId:
         """
@@ -244,7 +414,7 @@ class NostrClient:
             text: text to be published as kind 1 event
 
         Returns:
-            EventId: event id if successful or NostrClient.ERROR if unsuccesful
+            EventId: event id if successful
 
         Raises:
             RuntimeError: if the event can't be published
@@ -252,7 +422,7 @@ class NostrClient:
         event_builder = EventBuilder.text_note(text)
         return await self._async_publish_event(event_builder)
 
-    async def _async_publish_product(self, product: ProductData) -> EventId:
+    async def _async_publish_product(self, product: MerchantProduct) -> EventId:
         """
         Asynchronous function to create or update a NIP-15 Marketplace product with event kind 30018
 
@@ -260,7 +430,7 @@ class NostrClient:
             product: product to publish
 
         Returns:
-            EventId: event id if successful or NostrClient.ERROR if unsuccesfull
+            EventId: event id if successful
 
         Raises:
             RuntimeError: if the product can't be published
@@ -271,7 +441,7 @@ class NostrClient:
 
         # EventBuilder.product_data() has a bug with tag handling.
         # We use the function to create the content field and discard the eventbuilder
-        bad_event_builder = EventBuilder.product_data(product)
+        bad_event_builder = EventBuilder.product_data(product.to_product_data())
 
         # create an event from bad_event_builder to extract the content - not broadcasted
         bad_event = await self.client.sign_event_builder(bad_event_builder)
@@ -296,7 +466,7 @@ class NostrClient:
             picture: url to a png file with a picture for the profile
 
         Returns:
-            EventId: event id if successful or NostrClient.ERROR if unsuccesful
+            EventId: event id if successful
 
         Raises:
             RuntimeError: if the profile can't be published
@@ -308,7 +478,7 @@ class NostrClient:
         event_builder = EventBuilder.metadata(metadata_content)
         return await self._async_publish_event(event_builder)
 
-    async def _async_publish_stall(self, stall: StallData) -> EventId:
+    async def _async_publish_stall(self, stall: MerchantStall) -> EventId:
         """
         Asynchronous function to create or update a NIP-15 Marketplace stall with event kind 30017
 
@@ -316,12 +486,178 @@ class NostrClient:
             stall: stall to be published
 
         Returns:
-            EventId: event id if successful or NostrClient.ERROR if unsuccesfull
+            EventId: Id of the publication event
 
         Raises:
             RuntimeError: if the profile can't be published
         """
 
-        self.logger.info(f"Stall: {stall}")
-        event_builder = EventBuilder.stall_data(stall)
+        # good_event_builder = EventBuilder(Kind(30018), content).tags(
+        #     [Tag.identifier(product.id), Tag.coordinate(coordinate_tag)]
+        # )
+
+        self.logger.info(f" Merchant Stall: {stall}")
+        event_builder = EventBuilder.stall_data(stall.to_stall_data()).tags(
+            [
+                Tag.custom(
+                    TagKind.SINGLE_LETTER(SingleLetterTag.lowercase(Alphabet.G)),
+                    [stall.geohash],
+                ),
+            ]
+        )
         return await self._async_publish_event(event_builder)
+
+    async def _async_retrieve_all_stalls(self) -> Events:
+        """
+        Asynchronous function to retreive all stalls from a relay
+        This function is used internally to find Merchants.
+
+        Returns:
+            Events: events containing all stalls.
+
+        Raises:
+            RuntimeError: if the stalls can't be retrieved
+        """
+        try:
+            await self._async_connect()
+        except Exception as e:
+            raise RuntimeError("Unable to connect to the relay")
+
+        try:
+            filter = Filter().kind(Kind(30017))
+            events = await self.client.fetch_events_from(
+                urls=[self.relay], filter=filter, timeout=timedelta(seconds=2)
+            )
+            return events
+        except Exception as e:
+            raise RuntimeError(f"Unable to retrieve stalls: {e}")
+
+    async def _async_retrieve_products_from_seller(self, seller: PublicKey) -> Events:
+        """
+        Asynchronous function to retrieve the products for a given author
+
+        Args:
+            seller: PublicKey of the seller to retrieve the products for
+
+        Returns:
+            Events: list of events containing the products of the seller
+
+        Raises:
+            RuntimeError: if the products can't be retrieved
+        """
+        try:
+            await self._async_connect()
+        except Exception as e:
+            raise RuntimeError("Unable to connect to the relay")
+
+        try:
+            # print(f"Retrieving products from seller: {seller}")
+            filter = Filter().kind(Kind(30018)).authors([seller])
+            events = await self.client.fetch_events_from(
+                urls=[self.relay], filter=filter, timeout=timedelta(seconds=2)
+            )
+            return events
+        except Exception as e:
+            raise RuntimeError(f"Unable to retrieve stalls: {e}")
+
+    async def _async_retrieve_profile(self, author: PublicKey) -> NostrProfile:
+        """
+        Asynchronous function to retrieve the profile for a given author
+
+        Args:
+            author: PublicKey of the author to retrieve the profile for
+
+        Returns:
+            NostrProfile: profile of the author
+
+        Raises:
+            RuntimeError: if the profile can't be retrieved
+        """
+        try:
+            await self._async_connect()
+        except Exception as e:
+            raise RuntimeError("Unable to connect to the relay")
+
+        try:
+            metadata = await self.client.fetch_metadata(
+                public_key=author, timeout=timedelta(seconds=2)
+            )
+            return NostrProfile.from_metadata(metadata, author)
+        except Exception as e:
+            raise RuntimeError(f"Unable to retrieve metadata: {e}")
+
+    async def _async_retrieve_stalls_from_seller(self, seller: PublicKey) -> Events:
+        """
+        Asynchronous function to retrieve the stall for a given author
+
+        Args:
+            seller: PublicKey of the seller to retrieve the stall for
+
+        Returns:
+            Events: list of events containing the stalls of the seller
+
+        Raises:
+            RuntimeError: if the stall can't be retrieved
+        """
+        try:
+            await self._async_connect()
+        except Exception as e:
+            raise RuntimeError("Unable to connect to the relay")
+
+        try:
+            filter = Filter().kind(Kind(30017)).authors([seller])
+            events = await self.client.fetch_events_from(
+                urls=[self.relay], filter=filter, timeout=timedelta(seconds=2)
+            )
+            return events
+        except Exception as e:
+            raise RuntimeError(f"Unable to retrieve stalls: {e}")
+
+
+def generate_and_save_keys(env_var: str, env_path: Path) -> Keys:
+    """Generate new nostr keys and save the private key to .env file.
+
+    Args:
+        env_var: Name of the environment variable to store the key
+        env_path: Path to the .env file. If None, looks for .env in current directory
+
+    Returns:
+        The generated Keys object
+    """
+    # Generate new keys
+    keys = Keys.generate()
+    nsec = keys.secret_key().to_bech32()
+
+    # Determine .env path
+    if env_path is None:
+        env_path = Path.cwd() / ".env"
+
+    # Read existing .env content
+    env_content = ""
+    if env_path.exists():
+        with open(env_path, "r") as f:
+            env_content = f.read()
+
+    # Check if the env var already exists
+    lines = env_content.splitlines()
+    new_lines = []
+    var_found = False
+
+    for line in lines:
+        if line.startswith(f"{env_var}="):
+            new_lines.append(f"{env_var}={nsec}")
+            var_found = True
+        else:
+            new_lines.append(line)
+
+    # If var wasn't found, add it
+    if not var_found:
+        new_lines.append(f"{env_var}={nsec}")
+
+    # Write back to .env
+    with open(env_path, "w") as f:
+        f.write("\n".join(new_lines))
+        if new_lines:  # Add final newline if there's content
+            f.write("\n")
+
+    return keys

agentstr/nostr.pyi

@@ -0,0 +1,82 @@
+from logging import Logger
+from pathlib import Path
+from typing import ClassVar, List, Optional
+
+from nostr_sdk import (  # type: ignore
+    Client,
+    Event,
+    EventBuilder,
+    EventId,
+    Events,
+    Keys,
+    Kind,
+    Metadata,
+    NostrSigner,
+    ProductData,
+    PublicKey,
+    ShippingCost,
+    ShippingMethod,
+    StallData,
+    Tag,
+    Timestamp,
+)
+
+from agentstr.models import MerchantProduct, MerchantStall, NostrProfile
+
+# Re-export all needed types
+__all__ = [
+    "Event",
+    "EventBuilder",
+    "Events",
+    "EventId",
+    "Keys",
+    "Kind",
+    "Metadata",
+    "ProductData",
+    "PublicKey",
+    "ShippingCost",
+    "ShippingMethod",
+    "StallData",
+    "Timestamp",
+]
+
+class NostrClient:
+    logger: ClassVar[Logger]
+    relay: str
+    keys: Keys
+    nostr_signer: NostrSigner
+    client: Client
+
+    def __init__(self, relay: str, nsec: str) -> None: ...
+    def delete_event(
+        self, event_id: EventId, reason: Optional[str] = None
+    ) -> EventId: ...
+    def publish_event(self, event_builder: EventBuilder) -> EventId: ...
+    def publish_note(self, text: str) -> EventId: ...
+    def publish_product(self, product: MerchantProduct) -> EventId: ...
+    def publish_profile(self, name: str, about: str, picture: str) -> EventId: ...
+    def publish_stall(self, stall: MerchantStall) -> EventId: ...
+    def retrieve_products_from_seller(
+        self, seller: PublicKey
+    ) -> List[MerchantProduct]: ...
+    def retrieve_profile(self, public_key: PublicKey) -> NostrProfile: ...
+    def retrieve_stalls_from_seller(self, seller: PublicKey) -> List[StallData]: ...
+    def retrieve_sellers(self) -> set[NostrProfile]: ...
+    @classmethod
+    def set_logging_level(cls, logging_level: int) -> None: ...
+    async def _async_connect(self) -> None: ...
+    async def _async_publish_event(self, event_builder: EventBuilder) -> EventId: ...
+    async def _async_publish_note(self, text: str) -> EventId: ...
+    async def _async_publish_product(self, product: MerchantProduct) -> EventId: ...
+    async def _async_publish_profile(
+        self, name: str, about: str, picture: str
+    ) -> EventId: ...
+    async def _async_publish_stall(self, stall: MerchantStall) -> EventId: ...
+    async def _async_retrieve_all_stalls(self) -> Events: ...
+    async def _async_retrieve_products_from_seller(
+        self, seller: PublicKey
+    ) -> Events: ...
+    async def _async_retrieve_profile(self, author: PublicKey) -> NostrProfile: ...
+    async def _async_retrieve_stalls_from_seller(self, seller: PublicKey) -> Events: ...
+
+def generate_and_save_keys(env_var: str, env_path: Optional[Path] = None) -> Keys: ...