hiero-sdk-python 0.0.2.dev3__py3-none-any.whl

hedera_sdk_python/query/topic_info_query.py

@@ -0,0 +1,105 @@
+from hiero-sdk-python.query.query import Query
+from hiero-sdk-python.hapi.services import query_pb2, consensus_get_topic_info_pb2
+from hiero-sdk-python.consensus.topic_id import TopicId
+from hiero-sdk-python.consensus.topic_info import TopicInfo
+
+class TopicInfoQuery(Query):
+    """
+    A query to retrieve information about a specific Hedera topic.
+    """
+
+    def __init__(self, topic_id=None):
+        """
+        Initializes a new TopicInfoQuery instance with an optional topic_id.
+
+        Args:
+            topic_id (TopicId, optional): The ID of the topic to query.
+        """
+        super().__init__()
+        self.topic_id = topic_id
+        self._frozen = False 
+
+    def _require_not_frozen(self):
+        """
+        Ensures the query is not frozen before making changes.
+        """
+        if self._frozen:
+            raise ValueError("This query is frozen and cannot be modified.")
+
+    def set_topic_id(self, topic_id: TopicId):
+        """
+        Sets the ID of the topic to query.
+
+        Args:
+            topic_id (TopicId): The ID of the topic.
+
+        Returns:
+            TopicInfoQuery: Returns self for method chaining.
+        """
+        self._require_not_frozen()
+        self.topic_id = topic_id
+        return self
+
+    def freeze(self):
+        """
+        Marks the query as frozen, preventing further modification.
+
+        Returns:
+            TopicInfoQuery: Returns self for chaining.
+        """
+        self._frozen = True
+        return self
+
+    def _make_request(self):
+        """
+        Constructs the protobuf request for the query.
+
+        Returns:
+            Query: The protobuf query message.
+
+        Raises:
+            ValueError: If the topic ID is not set.
+        """
+        if not self.topic_id:
+            raise ValueError("Topic ID must be set before making the request.")
+
+        query_header = self._make_request_header()
+
+        topic_info_query = consensus_get_topic_info_pb2.ConsensusGetTopicInfoQuery()
+        topic_info_query.header.CopyFrom(query_header)
+        topic_info_query.topicID.CopyFrom(self.topic_id.to_proto())
+
+        query = query_pb2.Query()
+        query.consensusGetTopicInfo.CopyFrom(topic_info_query)
+        return query
+
+    def _get_status_from_response(self, response):
+        """
+        Extracts the status from the query response.
+
+        Args:
+            response: The response protobuf message.
+
+        Returns:
+            ResponseCode: The status code from the response.
+        """
+        return response.consensusGetTopicInfo.header.nodeTransactionPrecheckCode
+
+    def _map_response(self, response):
+        """
+        Maps the protobuf response to a TopicInfo instance.
+
+        Args:
+            response: The response protobuf message.
+
+        Returns:
+            TopicInfo: The topic info.
+
+        Raises:
+            Exception: If no topicInfo is returned in the response.
+        """
+        if not response.consensusGetTopicInfo.topicInfo:
+            raise Exception("No topicInfo returned in the response.")
+
+        proto_topic_info = response.consensusGetTopicInfo.topicInfo
+        return TopicInfo.from_proto(proto_topic_info)

hedera_sdk_python/query/topic_message_query.py

@@ -0,0 +1,105 @@
+from datetime import datetime
+from typing import Optional, Callable, Union
+import threading
+from hiero-sdk-python.consensus.topic_message import TopicMessage
+from hiero-sdk-python.hapi.mirror import consensus_service_pb2 as mirror_proto
+from hiero-sdk-python.hapi.services import basic_types_pb2, timestamp_pb2
+from hiero-sdk-python.consensus.topic_id import TopicId
+
+class TopicMessageQuery:
+    """
+    A query to subscribe to messages from a specific HCS topic, via a mirror node.
+    """
+
+    def __init__(
+        self,
+        topic_id: Optional[Union[str, TopicId]] = None,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        limit: Optional[int] = None,
+        chunking_enabled: bool = False,
+    ):
+        """
+        Initializes a new TopicMessageQuery instance.
+
+        Args:
+            topic_id (str or TopicId, optional): The ID of the topic to subscribe to.
+            start_time (datetime, optional): Start time for the subscription.
+            end_time (datetime, optional): End time for the subscription.
+            limit (int, optional): Maximum number of messages to retrieve.
+            chunking_enabled (bool, optional): Whether to enable chunking.
+        """
+        self._topic_id = self._parse_topic_id(topic_id) if topic_id else None
+        self._start_time = self._parse_timestamp(start_time) if start_time else None
+        self._end_time = self._parse_timestamp(end_time) if end_time else None
+        self._limit = limit
+        self._chunking_enabled = chunking_enabled
+
+    def _parse_topic_id(self, topic_id: Union[str, TopicId]):
+        if isinstance(topic_id, str):
+            parts = topic_id.strip().split(".")
+            if len(parts) != 3:
+                raise ValueError(f"Invalid topic ID string: {topic_id}")
+            shard, realm, topic = map(int, parts)
+            return basic_types_pb2.TopicID(shardNum=shard, realmNum=realm, topicNum=topic)
+        elif isinstance(topic_id, TopicId):
+            return topic_id.to_proto()
+        else:
+            raise TypeError("Invalid topic_id format. Must be a string or TopicId.")
+
+    def _parse_timestamp(self, dt: datetime):
+        seconds = int(dt.timestamp())
+        nanos = int((dt.timestamp() - seconds) * 1e9)
+        return timestamp_pb2.Timestamp(seconds=seconds, nanos=nanos)
+
+    def set_topic_id(self, topic_id: Union[str, TopicId]):
+        self._topic_id = self._parse_topic_id(topic_id)
+        return self
+
+    def set_start_time(self, dt: datetime):
+        self._start_time = self._parse_timestamp(dt)
+        return self
+
+    def set_end_time(self, dt: datetime):
+        self._end_time = self._parse_timestamp(dt)
+        return self
+
+    def set_limit(self, limit: int):
+        self._limit = limit
+        return self
+
+    def set_chunking_enabled(self, enabled: bool):
+        self._chunking_enabled = enabled
+        return self
+
+    def subscribe(
+        self,
+        client,
+        on_message: Callable[[TopicMessage], None],
+        on_error: Optional[Callable[[Exception], None]] = None,
+    ):
+        if not self._topic_id:
+            raise ValueError("Topic ID must be set before subscribing.")
+        if not client.mirror_stub:
+            raise ValueError("Client has no mirror_stub. Did you configure a mirror node address?")
+
+        request = mirror_proto.ConsensusTopicQuery(topicID=self._topic_id)
+        if self._start_time:
+            request.consensusStartTime.CopyFrom(self._start_time)
+        if self._end_time:
+            request.consensusEndTime.CopyFrom(self._end_time)
+        if self._limit is not None:
+            request.limit = self._limit
+
+        def run_stream():
+            try:
+                message_stream = client.mirror_stub.subscribeTopic(request)
+                for response in message_stream:
+                    msg_obj = TopicMessage.from_proto(response)
+                    on_message(msg_obj)
+            except Exception as e:
+                if on_error:
+                    on_error(e)
+
+        thread = threading.Thread(target=run_stream, daemon=True)
+        thread.start()

hedera_sdk_python/query/transaction_get_receipt_query.py

@@ -0,0 +1,128 @@
+from hiero-sdk-python.query.query import Query
+from hiero-sdk-python.hapi.services import transaction_get_receipt_pb2, query_pb2, query_header_pb2
+from hiero-sdk-python.response_code import ResponseCode
+from hiero-sdk-python.transaction.transaction_id import TransactionId
+from hiero-sdk-python.transaction.transaction_receipt import TransactionReceipt
+import traceback
+
+class TransactionGetReceiptQuery(Query):
+    """
+    A query to retrieve the receipt of a specific transaction from the Hedera network.
+
+    This class constructs and executes a query to obtain the receipt of a transaction,
+    which includes the transaction's status and other pertinent information.
+    """
+
+    def __init__(self, transaction_id=None):
+        """
+        Initializes a new instance of the TransactionGetReceiptQuery class.
+
+        Args:
+            transaction_id (TransactionId, optional): The ID of the transaction.
+        """
+        super().__init__()
+        self.transaction_id = transaction_id
+        self._frozen = False
+
+    def _require_not_frozen(self):
+        """
+        Ensures the query is not frozen before making changes.
+        """
+        if self._frozen:
+            raise ValueError("This query is frozen and cannot be modified.")
+
+    def set_transaction_id(self, transaction_id: TransactionId):
+        """
+        Sets the transaction ID for which to retrieve the receipt.
+
+        Args:
+            transaction_id (TransactionId): The ID of the transaction.
+
+        Returns:
+            TransactionGetReceiptQuery: The current instance for method chaining.
+        """
+        self._require_not_frozen()
+        self.transaction_id = transaction_id
+        return self
+
+    def freeze(self):
+        """
+        Marks the query as frozen, preventing further modification.
+
+        Returns:
+            TransactionGetReceiptQuery: The current instance for method chaining.
+        """
+        self._frozen = True
+        return self
+
+    def _is_payment_required(self):
+        """
+        Override the default in the base Query class:
+        This particular query does NOT require a payment.
+        """
+        return False
+
+    def _make_request(self):
+        """
+        Constructs the protobuf request for the transaction receipt query.
+
+        Returns:
+            Query: The protobuf Query object containing the transaction receipt query.
+
+        Raises:
+            ValueError: If the transaction ID is not set.
+            Exception: If an error occurs during request construction.
+        """
+        try:
+            if not self.transaction_id:
+                raise ValueError("Transaction ID must be set before making the request.")
+
+            query_header = query_header_pb2.QueryHeader()
+            query_header.responseType = query_header_pb2.ResponseType.ANSWER_ONLY
+
+            transaction_get_receipt = transaction_get_receipt_pb2.TransactionGetReceiptQuery()
+            transaction_get_receipt.header.CopyFrom(query_header)
+            transaction_get_receipt.transactionID.CopyFrom(self.transaction_id.to_proto())
+
+            query = query_pb2.Query()
+            if not hasattr(query, 'transactionGetReceipt'):
+                raise AttributeError("Query object has no attribute 'transactionGetReceipt'")
+            query.transactionGetReceipt.CopyFrom(transaction_get_receipt)
+
+            return query
+        except Exception as e:
+            print(f"Exception in _make_request: {e}")
+            traceback.print_exc()
+            raise
+
+    def _get_status_from_response(self, response):
+        """
+        Extracts the status code from the response header.
+
+        Args:
+            response (Response): The response received from the network.
+
+        Returns:
+            int: The status code indicating the result of the query.
+        """
+        header = response.transactionGetReceipt.header
+        return header.nodeTransactionPrecheckCode
+
+    def _map_response(self, response):
+        """
+        Maps the response to a TransactionReceipt object.
+
+        Args:
+            response (Response): The response received from the network.
+
+        Returns:
+            TransactionReceipt: The transaction receipt extracted from the response.
+
+        Raises:
+            Exception: If the transaction receipt is not found in the response.
+        """
+        if response.transactionGetReceipt and response.transactionGetReceipt.receipt:
+            receipt_proto = response.transactionGetReceipt.receipt
+            return TransactionReceipt.from_proto(receipt_proto)
+        else:
+            raise Exception("Transaction receipt not found in the response.")