chore: fix rebase

Signed-off-by: Manish Dait <daitmanish88@gmail.com>

Author: manishdait

src/hiero_sdk_python/consensus/topic_message_submit_transaction.py

@@ -4,7 +4,6 @@
 from typing import Literal, overload
 
 from hiero_sdk_python.channels import _Channel
-from typing import List, Literal, Optional, overload
 from hiero_sdk_python.client.client import Client
 from hiero_sdk_python.consensus.topic_id import TopicId
 from hiero_sdk_python.crypto.private_key import PrivateKey
@@ -404,7 +403,7 @@ def sign(self, private_key: PrivateKey):
 
         super().sign(private_key)
         return self
-    
+
     @property
     def body_size_all_chunks(self) -> list[int]:
         """Returns an array of body sizes for transactions with multiple chunks."""
@@ -416,8 +415,7 @@ def body_size_all_chunks(self) -> list[int]:
         for transaction_id in self._transaction_ids:
             self.transaction_id = transaction_id
             sizes.append(self.body_size)
-        
+
         self._current_index = original_index
         self.transaction_id = original_transaction_id
         return sizes
-       

src/hiero_sdk_python/file/file_append_transaction.py

@@ -16,7 +16,6 @@
 import math
 from typing import TYPE_CHECKING, Any, Literal, overload
 
-from typing import TYPE_CHECKING, Any, List, Literal, Optional, overload
 from hiero_sdk_python.file.file_id import FileId
 from hiero_sdk_python.hapi.services import file_append_pb2, timestamp_pb2
 from hiero_sdk_python.hapi.services.schedulable_transaction_body_pb2 import (
@@ -30,10 +29,8 @@
 # Use TYPE_CHECKING to avoid circular import errors
 if TYPE_CHECKING:
     from hiero_sdk_python.channels import _Channel
-    from hiero_sdk_python.client import Client
+    from hiero_sdk_python.client.client import Client
     from hiero_sdk_python.crypto.private_key import PrivateKey
-
-    from hiero_sdk_python.channels import _Channel
     from hiero_sdk_python.executable import _Method
     from hiero_sdk_python.transaction.transaction import TransactionReceipt
     from hiero_sdk_python.transaction.transaction_response import TransactionResponse
@@ -289,35 +286,12 @@ def freeze_with(self, client: Client) -> FileAppendTransaction:
         if self._transaction_body_bytes:
             return self
 
-        if self.transaction_id is None:
-            if client is None:
-                raise ValueError(
-                    "Transaction ID must be set before freezing. Use freeze_with(client) or set_transaction_id()."
-                )
-
-            self.transaction_id = client.generate_transaction_id()
-
-        
         self._resolve_transaction_id(client)
 
         # Generate transaction IDs for all chunks
         if not self._transaction_ids:
             base_timestamp = self.transaction_id.valid_start
 
-        for i in range(self.get_required_chunks()):
-            if i == 0:
-                # First chunk uses the original transaction ID
-                chunk_transaction_id = self.transaction_id
-            else:
-                # Subsequent chunks get incremented timestamps
-                # Add i nanoseconds to space out chunks
-                chunk_valid_start = timestamp_pb2.Timestamp(
-                    seconds=base_timestamp.seconds, nanos=base_timestamp.nanos + i
-                )
-                chunk_transaction_id = TransactionId(
-                    account_id=self.transaction_id.account_id, valid_start=chunk_valid_start
-                )
-            self._transaction_ids.append(chunk_transaction_id)
             for i in range(self.get_required_chunks()):
                 if i == 0:
                     # First chunk uses the original transaction ID
@@ -326,12 +300,10 @@ def freeze_with(self, client: Client) -> FileAppendTransaction:
                     # Subsequent chunks get incremented timestamps
                     # Add i nanoseconds to space out chunks
                     chunk_valid_start = timestamp_pb2.Timestamp(
-                        seconds=base_timestamp.seconds,
-                        nanos=base_timestamp.nanos + i
+                        seconds=base_timestamp.seconds, nanos=base_timestamp.nanos + i
                     )
                     chunk_transaction_id = TransactionId(
-                        account_id=self.transaction_id.account_id,
-                        valid_start=chunk_valid_start
+                        account_id=self.transaction_id.account_id, valid_start=chunk_valid_start
                     )
 
                 self._transaction_ids.append(chunk_transaction_id)
@@ -476,7 +448,6 @@ def sign(self, private_key: PrivateKey) -> FileAppendTransaction:
         super().sign(private_key)
         return self
 
-    
     @property
     def body_size_all_chunks(self) -> list[int]:
         """Returns an array of body sizes for transactions with multiple chunks."""
@@ -488,8 +459,7 @@ def body_size_all_chunks(self) -> list[int]:
         for transaction_id in self._transaction_ids:
             self.transaction_id = transaction_id
             sizes.append(self.body_size)
-        
+
         self._current_chunk_index = original_index
         self.transaction_id = original_transaction_id
         return sizes
-    

src/hiero_sdk_python/node.py

@@ -126,7 +126,7 @@ def _get_channel(self):
             if self._root_certificates:
                 # Use the certificate that is provided
                 self._node_pem_cert = self._root_certificates
-            
+
             else:
                 # Fetch pem_cert for the node
                 self._node_pem_cert = self._fetch_server_certificate_pem()

src/hiero_sdk_python/transaction/transaction.py

@@ -226,34 +226,28 @@ def _to_proto(self):
 
         signed_transaction = transaction_contents_pb2.SignedTransaction(bodyBytes=body_bytes, sigMap=sig_map)
 
+        return transaction_pb2.Transaction(signedTransactionBytes=signed_transaction.SerializeToString())
 
-        return transaction_pb2.Transaction(
-            signedTransactionBytes=signed_transaction.SerializeToString()
-        )
-    
-    def _resolve_transaction_id(self, client: "Client"):
+    def _resolve_transaction_id(self, client: Client):
         if self.transaction_id is not None:
             return
-        
+
         if client is not None:
             operator_account_id = client.operator_account_id
             if operator_account_id is not None:
                 self.transaction_id = client.generate_transaction_id()
             else:
-                raise ValueError(
-                    "Client must have an operator_account or transactionId must be set."
-                )
+                raise ValueError("Client must have an operator_account or transactionId must be set.")
         else:
             raise ValueError(
                 "Transaction ID must be set before freezing. Use freeze_with(client) or set_transaction_id()."
             )
-        
-    def _resolve_node_ids(self, client: "Client"):
-        if self.node_account_id is None and len(self.node_account_ids) == 0:
-            if client is None:
-                raise ValueError(
-                    "Node account ID must be set before freezing. Use freeze_with(client) or manually set node_account_ids."
-                )
+
+    def _resolve_node_ids(self, client: Client):
+        if self.node_account_id is None and len(self.node_account_ids) == 0 and client is None:
+            raise ValueError(
+                "Node account ID must be set before freezing. Use freeze_with(client) or manually set node_account_ids."
+            )
 
     def freeze(self):
         """
@@ -275,7 +269,7 @@ def freeze(self):
         """
         return self.freeze_with(None)
 
-    def freeze_with(self, client: "Client"):
+    def freeze_with(self, client: Client):
         """
         Freezes the transaction by building the transaction body and setting necessary IDs.
 
@@ -291,13 +285,11 @@ def freeze_with(self, client: "Client"):
         if self._transaction_body_bytes:
             return self
 
-        
         # Check transaction_id and node id to be set when using freeze()
         self._resolve_transaction_id(client)
 
-
         self._resolve_node_ids(client)
-        
+
         # We iterate through every node in the client's network
         # For each node, set the node_account_id and build the transaction body
         # This allows the transaction to be submitted to any node in the network
@@ -934,7 +926,7 @@ def size(self) -> int:
         """Returns the total transaction size in bytes after protobuf encoding"""
         self._require_frozen()
         return self._make_request().ByteSize()
-    
+
     @property
     def body_size(self) -> int:
         """Returns just the transaction body size in bytes after encoding"""

tests/integration/file_append_transaction_e2e_test.py

@@ -4,16 +4,12 @@
 from pytest import mark
 
 from hiero_sdk_python.account.account_id import AccountId
-from hiero_sdk_python.file.file_create_transaction import FileCreateTransaction
 from hiero_sdk_python.file.file_append_transaction import FileAppendTransaction
 from hiero_sdk_python.file.file_contents_query import FileContentsQuery
 from hiero_sdk_python.file.file_create_transaction import FileCreateTransaction
 from hiero_sdk_python.response_code import ResponseCode
-
-from hiero_sdk_python.hbar import Hbar
-from hiero_sdk_python.exceptions import PrecheckError
 from hiero_sdk_python.transaction.transaction_id import TransactionId
-from tests.integration.utils import env, IntegrationTestEnv
+
 
 # Generate big contents for chunking tests - similar to JavaScript bigContents
 BIG_CONTENTS = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. " * 250  # ~13,750 characters
@@ -289,7 +285,8 @@ def test_integration_file_append_transaction_method_chaining(env):
 
     append_receipt = append_tx.execute(env.client)
     assert append_receipt.status == ResponseCode.SUCCESS
-    assert append_receipt.status == ResponseCode.SUCCESS 
+    assert append_receipt.status == ResponseCode.SUCCESS
+
 
 @pytest.mark.integration
 def test_file_append_chunk_transaction_can_execute_with_manual_freeze(env):
@@ -307,22 +304,22 @@ def test_file_append_chunk_transaction_can_execute_with_manual_freeze(env):
     file_contents = FileContentsQuery().set_file_id(file_id).execute(env.client)
     assert file_contents == b""
 
-    content = "A" * (4000) # content with (4000/1024) bytes ie approx 4 chunks
+    content = "A" * (4000)  # content with (4000/1024) bytes ie approx 4 chunks
 
     tx = (
         FileAppendTransaction()
         .set_file_id(file_id)
         .set_chunk_size(1024)
         .set_contents(content)
         .set_transaction_id(TransactionId.generate(env.client.operator_account_id))
-        .set_node_account_id(AccountId(0,0,3))
+        .set_node_account_id(AccountId(0, 0, 3))
         .freeze()
     )
 
     tx.sign(env.client.operator_private_key)
 
     receipt = tx.execute(env.client)
-    
+
     assert receipt.status == ResponseCode.SUCCESS
 
     file_contents = FileContentsQuery().set_file_id(file_id).execute(env.client)

tests/integration/topic_message_submit_transaction_e2e_test.py

@@ -19,9 +19,9 @@
 from hiero_sdk_python.response_code import ResponseCode
 from hiero_sdk_python.tokens.custom_fixed_fee import CustomFixedFee
 from hiero_sdk_python.transaction.custom_fee_limit import CustomFeeLimit
-
 from hiero_sdk_python.transaction.transaction_id import TransactionId
 
+
 def create_topic(client, admin_key=None, submit_key=None, custom_fees=None):
     """Helper transaction for creating a topic."""
     tx = TopicCreateTransaction(memo="Python SDK topic")
@@ -300,32 +300,28 @@ def test_integration_topic_message_submit_transaction_fails_if_required_chunk_gr
     delete_topic(env.client, topic_id)
 
 
-
 @pytest.mark.integration
 def test_topic_message_submit_transaction_can_submit_a_large_message_manual_freeze(env):
     """Test topic message submit transaction can submit large message with manual freeze."""
-    topic_id = create_topic(
-        client=env.client,
-        admin_key=env.operator_key
-    )
+    topic_id = create_topic(client=env.client, admin_key=env.operator_key)
 
     info = TopicInfoQuery().set_topic_id(topic_id).execute(env.client)
     assert info.sequence_number == 0
 
-    message = "A" * (1024 * 14) # message with (1024 * 14) bytes ie 14 chunks
+    message = "A" * (1024 * 14)  # message with (1024 * 14) bytes ie 14 chunks
 
     message_tx = (
         TopicMessageSubmitTransaction()
         .set_topic_id(topic_id)
         .set_message(message)
         .set_transaction_id(TransactionId.generate(env.client.operator_account_id))
-        .set_node_account_id(AccountId(0,0,3))
+        .set_node_account_id(AccountId(0, 0, 3))
         .freeze()
     )
 
     message_tx.sign(env.client.operator_private_key)
     message_receipt = message_tx.execute(env.client)
-    
+
     assert message_receipt.status == ResponseCode.SUCCESS
 
     info = TopicInfoQuery().set_topic_id(topic_id).execute(env.client)

tests/unit/mock_server.py

@@ -181,12 +181,6 @@ def mock_hedera_servers(response_sequences):
 
         client = Client(network)
 
-        # Force non-tls channel
-        for node in client.network.nodes:
-            node._address._is_transport_security = lambda: False
-            node._set_verify_certificates(False)
-            node._close()
-
         client.logger.set_level(LogLevel.DISABLED)
         # Set the operator
         key = PrivateKey.generate()

tests/unit/topic_message_submit_transaction_test.py

@@ -6,7 +6,6 @@
 
 import pytest
 
-from hiero_sdk_python.account.account_id import AccountId
 from hiero_sdk_python.consensus.topic_message_submit_transaction import TopicMessageSubmitTransaction
 from hiero_sdk_python.exceptions import PrecheckError, ReceiptStatusError
 from hiero_sdk_python.hapi.services import (
@@ -505,13 +504,10 @@ def test_topic_submit_execute_returns_failed_receipt_by_default(topic_id):
 
         assert receipt.status == ResponseCode.INVALID_SIGNATURE
 
+
 def test_topic_submit_message_raises_error_on_freeze(topic_id):
     """Test transaction raises error on freeze when the transaction_id and node_id not set"""
-    tx = (
-        TopicMessageSubmitTransaction()
-        .set_topic_id(topic_id)
-        .set_message("Hello Hiero")
-    )
+    tx = TopicMessageSubmitTransaction().set_topic_id(topic_id).set_message("Hello Hiero")
 
     with pytest.raises(ValueError):
         tx.freeze()

tests/unit/transaction_test.py

@@ -4,7 +4,6 @@
 
 from hiero_sdk_python.account.account_create_transaction import AccountCreateTransaction
 from hiero_sdk_python.account.account_id import AccountId
-from hiero_sdk_python.consensus.topic_id import TopicId
 from hiero_sdk_python.consensus.topic_message_submit_transaction import TopicMessageSubmitTransaction
 from hiero_sdk_python.crypto.private_key import PrivateKey
 from hiero_sdk_python.exceptions import ReceiptStatusError
@@ -275,9 +274,7 @@ def test_tx_with_larger_content_should_have_larger_tx_body(transaction_id, accou
     assert tx1.body_size < tx2.body_size
 
 
-def test_tx_without_optional_fields_should_have_smaller_tx_body(
-    transaction_id, account_id
-):
+def test_tx_without_optional_fields_should_have_smaller_tx_body(transaction_id, account_id):
     """Test transaction with without optional fields should have smaller transaction body."""
     key = PrivateKey.generate()
     tx1 = (
@@ -343,7 +340,7 @@ def test_file_append_single_chunk_tx_return_list_of_len_one(file_id, account_id,
 def test_message_submit_chunk_tx_should_return_list_of_body_sizes(topic_id, account_id, transaction_id):
     """Test topic message submit tx should return array of body sizes for multi-chunk transaction."""
     chunk_size = 1024
-    message= "a" * (chunk_size * 3)
+    message = "a" * (chunk_size * 3)
 
     tx = (
         TopicMessageSubmitTransaction()
@@ -377,9 +374,7 @@ def test_message_submit_single_chunk_tx_return_list_of_len_one(topic_id, account
     assert len(sizes) == 1
 
 
-def test_tx_with_no_content_should_return_single_body_chunk(
-    file_id, account_id, transaction_id
-):
+def test_tx_with_no_content_should_return_single_body_chunk(file_id, account_id, transaction_id):
     """Test should return single body chunk for transaction with no content."""
     tx = (
         FileAppendTransaction()