algokit-utils 3.0.0b4__py3-none-any.whl → 3.0.0b6__py3-none-any.whl

algokit_utils/clients/client_manager.py

@@ -77,8 +77,8 @@ def _get_config_from_environment(environment_prefix: str) -> AlgoClientNetworkCo
     port = os.getenv(f"{environment_prefix}_PORT")
     if port:
         parsed = parse.urlparse(server)
-        server = parsed._replace(netloc=f"{parsed.hostname}:{port}").geturl()
-    return AlgoClientNetworkConfig(server, os.getenv(f"{environment_prefix}_TOKEN", ""))
+        server = parsed._replace(netloc=f"{parsed.hostname}").geturl()
+    return AlgoClientNetworkConfig(server, os.getenv(f"{environment_prefix}_TOKEN", ""), port=port)
 
 
 class ClientManager:
@@ -351,15 +351,18 @@ class ClientManager:
         )
 
     @staticmethod
-    def get_algod_client(config: AlgoClientNetworkConfig | None = None) -> AlgodClient:
+    def get_algod_client(config: AlgoClientNetworkConfig) -> AlgodClient:
         """Get an Algod client from config or environment.
 
         :param config: Optional client configuration
         :return: Algod client instance
         """
-        config = config or _get_config_from_environment("ALGOD")
         headers = {"X-Algo-API-Token": config.token or ""}
-        return AlgodClient(algod_token=config.token or "", algod_address=config.server, headers=headers)
+        return AlgodClient(
+            algod_token=config.token or "",
+            algod_address=config.full_url(),
+            headers=headers,
+        )
 
     @staticmethod
     def get_algod_client_from_environment() -> AlgodClient:
@@ -370,14 +373,13 @@ class ClientManager:
         return ClientManager.get_algod_client(ClientManager.get_algod_config_from_environment())
 
     @staticmethod
-    def get_kmd_client(config: AlgoClientNetworkConfig | None = None) -> KMDClient:
+    def get_kmd_client(config: AlgoClientNetworkConfig) -> KMDClient:
         """Get a KMD client from config or environment.
 
         :param config: Optional client configuration
         :return: KMD client instance
         """
-        config = config or _get_config_from_environment("KMD")
-        return KMDClient(config.token, config.server)
+        return KMDClient(config.token, config.full_url())
 
     @staticmethod
     def get_kmd_client_from_environment() -> KMDClient:
@@ -388,15 +390,18 @@ class ClientManager:
         return ClientManager.get_kmd_client(ClientManager.get_kmd_config_from_environment())
 
     @staticmethod
-    def get_indexer_client(config: AlgoClientNetworkConfig | None = None) -> IndexerClient:
+    def get_indexer_client(config: AlgoClientNetworkConfig) -> IndexerClient:
         """Get an Indexer client from config or environment.
 
         :param config: Optional client configuration
         :return: Indexer client instance
         """
-        config = config or _get_config_from_environment("INDEXER")
         headers = {"X-Indexer-API-Token": config.token}
-        return IndexerClient(indexer_token=config.token, indexer_address=config.server, headers=headers)
+        return IndexerClient(
+            indexer_token=config.token,
+            indexer_address=config.full_url(),
+            headers=headers,
+        )
 
     @staticmethod
     def get_indexer_client_from_environment() -> IndexerClient:
@@ -611,7 +616,7 @@ class ClientManager:
             else {"algod": 4001, "indexer": 8980, "kmd": 4002}[config_or_port]
         )
 
-        return AlgoClientNetworkConfig(server=f"http://localhost:{port}", token="a" * 64)
+        return AlgoClientNetworkConfig(server="http://localhost", token="a" * 64, port=port)
 
     @staticmethod
     def get_algod_config_from_environment() -> AlgoClientNetworkConfig:

algokit_utils/config.py

@@ -2,71 +2,67 @@ import logging
 import os
 from collections.abc import Callable
 from pathlib import Path
-from typing import Any
 
 # Environment variable to override the project root
 ALGOKIT_PROJECT_ROOT = os.getenv("ALGOKIT_PROJECT_ROOT")
 ALGOKIT_CONFIG_FILENAME = ".algokit.toml"
 
 
-class AlgoKitLogger:
-    def __init__(self) -> None:
-        self._logger = logging.getLogger("algokit")
-        self._setup_logger()
-
-    def _setup_logger(self) -> None:
-        formatter = logging.Formatter("%(levelname)s: %(message)s")
-        handler = logging.StreamHandler()
-        handler.setFormatter(formatter)
-        self._logger.addHandler(handler)
-        self._logger.setLevel(logging.INFO)
-
-    def _get_logger(self, *, suppress_log: bool = False) -> logging.Logger:
-        if suppress_log:
-            null_logger = logging.getLogger("null")
-            null_logger.addHandler(logging.NullHandler())
-            return null_logger
-        return self._logger
+class AlgoKitLogger(logging.Logger):
+    def __init__(self, name: str = "algokit-utils-py", level: int = logging.NOTSET):
+        super().__init__(name, level)
+        self._setup_handler()
 
-    def error(self, message: str, *args: Any, suppress_log: bool = False, **kwargs: Any) -> None:
-        """Log an error message, optionally suppressing output"""
-        self._get_logger(suppress_log=suppress_log).error(message, *args, **kwargs)
+    def _setup_handler(self) -> None:
+        # Only add the handler if no handlers are already set.
+        if not self.handlers:
+            formatter = logging.Formatter("%(levelname)s: %(message)s")
+            handler = logging.StreamHandler()
+            handler.setFormatter(formatter)
+            self.addHandler(handler)
 
-    def exception(self, message: str, *args: Any, suppress_log: bool = False, **kwargs: Any) -> None:
-        """Log an exception message, optionally suppressing output"""
-        self._get_logger(suppress_log=suppress_log).exception(message, *args, **kwargs)
+    def _log(self, level: int, msg: object, args, exc_info=None, extra=None, stack_info=False, stacklevel=1) -> None:  # type: ignore[no-untyped-def]  # noqa: FBT002, ANN001
+        """
+        Overrides the base _log method to allow suppressing individual log calls.
+        When a caller passes suppress_log=True in the extra keyword, the log call is ignored.
+        """
 
-    def warning(self, message: str, *args: Any, suppress_log: bool = False, **kwargs: Any) -> None:
-        """Log a warning message, optionally suppressing output"""
-        self._get_logger(suppress_log=suppress_log).warning(message, *args, **kwargs)
+        # Check if the 'suppress_log' flag is provided in the extra dictionary.
+        if extra and extra.get("suppress_log", False):
+            return
+        # Call the parent _log
+        super()._log(level, msg, args, exc_info, extra, stack_info, stacklevel)
 
-    def info(self, message: str, *args: Any, suppress_log: bool = False, **kwargs: Any) -> None:
-        """Log an info message, optionally suppressing output"""
-        self._get_logger(suppress_log=suppress_log).info(message, *args, **kwargs)
+    @classmethod
+    def get_null_logger(cls) -> logging.Logger:
+        """Return a logger that does nothing (a null logger)."""
+        null_logger = logging.getLogger("null")
+        null_logger.handlers.clear()
+        null_logger.addHandler(logging.NullHandler())
+        null_logger.propagate = False
+        return null_logger
 
-    def debug(self, message: str, *args: Any, suppress_log: bool = False, **kwargs: Any) -> None:
-        """Log a debug message, optionally suppressing output"""
-        self._get_logger(suppress_log=suppress_log).debug(message, *args, **kwargs)
 
-    def verbose(self, message: str, *args: Any, suppress_log: bool = False, **kwargs: Any) -> None:
-        """Log a verbose message (maps to debug), optionally suppressing output"""
-        self._get_logger(suppress_log=suppress_log).debug(message, *args, **kwargs)
+# Set our custom logger class as the default.
+logging.setLoggerClass(AlgoKitLogger)
 
 
 class UpdatableConfig:
-    """Class to manage and update configuration settings for the AlgoKit project.
+    """
+    Class to manage and update configuration settings for the AlgoKit project.
 
     Attributes:
         debug (bool): Indicates whether debug mode is enabled.
         project_root (Path | None): The path to the project root directory.
         trace_all (bool): Indicates whether to trace all operations.
-        trace_buffer_size_mb (int): The size of the trace buffer in megabytes.
+        trace_buffer_size_mb (int | float): The size of the trace buffer in megabytes.
         max_search_depth (int): The maximum depth to search for a specific file.
-        populate_app_call_resources (bool): Indicates whether to populate app call resources.
+        populate_app_call_resources (bool): Whether to populate app call resources.
+        logger (logging.Logger): The logger instance to use. Defaults to an AlgoKitLogger instance.
     """
 
     def __init__(self) -> None:
-        self._logger = AlgoKitLogger()
+        self._logger: logging.Logger = AlgoKitLogger()
         self._debug: bool = False
         self._project_root: Path | None = None
         self._trace_all: bool = False
@@ -76,17 +72,20 @@ class UpdatableConfig:
         self._configure_project_root()
 
     def _configure_project_root(self) -> None:
-        """Configures the project root by searching for a specific file within a depth limit."""
+        """
+        Configures the project root by searching for a specific file within a depth limit.
+        """
         current_path = Path(__file__).resolve()
         for _ in range(self._max_search_depth):
-            self.logger.debug(f"Searching in: {current_path}")
+            self._logger.debug(f"Searching in: {current_path}")
             if (current_path / ALGOKIT_CONFIG_FILENAME).exists():
                 self._project_root = current_path
                 break
             current_path = current_path.parent
 
     @property
-    def logger(self) -> AlgoKitLogger:
+    def logger(self) -> logging.Logger:
+        """Returns the logger instance."""
         return self._logger
 
     @property
@@ -101,7 +100,7 @@ class UpdatableConfig:
 
     @property
     def trace_all(self) -> bool:
-        """Indicates whether to store simulation traces for all operations."""
+        """Indicates whether simulation traces for all operations should be stored."""
         return self._trace_all
 
     @property
@@ -111,10 +110,13 @@ class UpdatableConfig:
 
     @property
     def populate_app_call_resource(self) -> bool:
+        """Indicates whether or not to populate app call resources."""
         return self._populate_app_call_resources
 
     def with_debug(self, func: Callable[[], str | None]) -> None:
-        """Executes a function with debug mode temporarily enabled."""
+        """
+        Executes a function with debug mode temporarily enabled.
+        """
         original_debug = self._debug
         try:
             self._debug = True
@@ -131,26 +133,27 @@ class UpdatableConfig:
         trace_buffer_size_mb: float = 256,
         max_search_depth: int = 10,
         populate_app_call_resources: bool = False,
+        logger: logging.Logger | None = None,
     ) -> None:
         """
         Configures various settings for the application.
-        Please note, when `project_root` is not specified, by default config will attempt to find the `algokit.toml` by
-        scanning the parent directories according to the `max_search_depth` parameter.
-        Alternatively value can also be set via the `ALGOKIT_PROJECT_ROOT` environment variable.
-        If you are executing the config from an algokit compliant project, you can simply call
-        `config.configure(debug=True)`.
-
-        :param debug: Indicates whether debug mode is enabled.
-        :param project_root: The path to the project root directory. Defaults to None.
-        :param trace_all: Indicates whether to trace all operations. Defaults to False. Which implies that
-                only the operations that are failed will be traced by default.
-        :param trace_buffer_size_mb: The size of the trace buffer in megabytes. Defaults to 256
-        :param max_search_depth: The maximum depth to search for a specific file. Defaults to 10
-        :param populate_app_call_resources: Indicates whether to populate app call resources. Defaults to False
+
+        :param debug: Whether debug mode is enabled.
+        :param project_root: The path to the project root directory.
+        :param trace_all: Whether to trace all operations. Defaults to False.
+        :param trace_buffer_size_mb: The trace buffer size in megabytes. Defaults to 256.
+        :param max_search_depth: The maximum depth to search for a specific file. Defaults to 10.
+        :param populate_app_call_resources: Whether to populate app call resources. Defaults to False.
+        :param logger: A custom logger to use. Defaults to AlgoKitLogger instance.
         """
+        if logger is not None:
+            self._logger = logger
 
         if debug is not None:
             self._debug = debug
+            # Update logger's level so debug messages are processed only when debug is True.
+            self._logger.setLevel(logging.DEBUG)
+
         if project_root is not None:
             self._project_root = project_root.resolve(strict=True)
         elif debug is not None and ALGOKIT_PROJECT_ROOT:

algokit_utils/models/amount.py

@@ -13,58 +13,34 @@ class AlgoAmount:
     """Wrapper class to ensure safe, explicit conversion between µAlgo, Algo and numbers.
 
     :example:
-    >>> amount = AlgoAmount(algos=1)
-    >>> amount = AlgoAmount(algo=1)
-    >>> amount = AlgoAmount.from_algos(1)
-    >>> amount = AlgoAmount.from_algo(1)
-    >>> amount = AlgoAmount(micro_algos=1_000_000)
-    >>> amount = AlgoAmount(micro_algo=1_000_000)
-    >>> amount = AlgoAmount.from_micro_algos(1_000_000)
-    >>> amount = AlgoAmount.from_micro_algo(1_000_000)
+        >>> amount = AlgoAmount(algo=1)
+        >>> amount = AlgoAmount.from_algo(1)
+        >>> amount = AlgoAmount(micro_algo=1_000_000)
+        >>> amount = AlgoAmount.from_micro_algo(1_000_000)
     """
 
-    @overload
-    def __init__(self, *, micro_algos: int) -> None: ...
-
     @overload
     def __init__(self, *, micro_algo: int) -> None: ...
 
-    @overload
-    def __init__(self, *, algos: int | Decimal) -> None: ...
-
     @overload
     def __init__(self, *, algo: int | Decimal) -> None: ...
 
     def __init__(
         self,
         *,
-        micro_algos: int | None = None,
         micro_algo: int | None = None,
-        algos: int | Decimal | None = None,
         algo: int | Decimal | None = None,
     ):
-        if micro_algos is None and micro_algo is None and algos is None and algo is None:
+        if micro_algo is None and algo is None:
             raise ValueError("No amount provided")
 
-        if micro_algos is not None:
-            self.amount_in_micro_algo = int(micro_algos)
-        elif micro_algo is not None:
+        if micro_algo is not None:
             self.amount_in_micro_algo = int(micro_algo)
-        elif algos is not None:
-            self.amount_in_micro_algo = int(algos * algosdk.constants.MICROALGOS_TO_ALGOS_RATIO)
         elif algo is not None:
             self.amount_in_micro_algo = int(algo * algosdk.constants.MICROALGOS_TO_ALGOS_RATIO)
         else:
             raise ValueError("Invalid amount provided")
 
-    @property
-    def micro_algos(self) -> int:
-        """Return the amount as a number in µAlgo.
-
-        :returns: The amount in µAlgo.
-        """
-        return self.amount_in_micro_algo
-
     @property
     def micro_algo(self) -> int:
         """Return the amount as a number in µAlgo.
@@ -73,14 +49,6 @@ class AlgoAmount:
         """
         return self.amount_in_micro_algo
 
-    @property
-    def algos(self) -> Decimal:
-        """Return the amount as a number in Algo.
-
-        :returns: The amount in Algo.
-        """
-        return algosdk.util.microalgos_to_algos(self.amount_in_micro_algo)  # type: ignore[no-any-return]
-
     @property
     def algo(self) -> Decimal:
         """Return the amount as a number in Algo.
@@ -89,18 +57,6 @@ class AlgoAmount:
         """
         return algosdk.util.microalgos_to_algos(self.amount_in_micro_algo)  # type: ignore[no-any-return]
 
-    @staticmethod
-    def from_algos(amount: int | Decimal) -> AlgoAmount:
-        """Create an AlgoAmount object representing the given number of Algo.
-
-        :param amount: The amount in Algo.
-        :returns: An AlgoAmount instance.
-
-        :example:
-        >>> amount = AlgoAmount.from_algos(1)
-        """
-        return AlgoAmount(algos=amount)
-
     @staticmethod
     def from_algo(amount: int | Decimal) -> AlgoAmount:
         """Create an AlgoAmount object representing the given number of Algo.
@@ -109,22 +65,10 @@ class AlgoAmount:
         :returns: An AlgoAmount instance.
 
         :example:
-        >>> amount = AlgoAmount.from_algo(1)
+            >>> amount = AlgoAmount.from_algo(1)
         """
         return AlgoAmount(algo=amount)
 
-    @staticmethod
-    def from_micro_algos(amount: int) -> AlgoAmount:
-        """Create an AlgoAmount object representing the given number of µAlgo.
-
-        :param amount: The amount in µAlgo.
-        :returns: An AlgoAmount instance.
-
-        :example:
-        >>> amount = AlgoAmount.from_micro_algos(1_000_000)
-        """
-        return AlgoAmount(micro_algos=amount)
-
     @staticmethod
     def from_micro_algo(amount: int) -> AlgoAmount:
         """Create an AlgoAmount object representing the given number of µAlgo.
@@ -133,7 +77,7 @@ class AlgoAmount:
         :returns: An AlgoAmount instance.
 
         :example:
-        >>> amount = AlgoAmount.from_micro_algo(1_000_000)
+            >>> amount = AlgoAmount.from_micro_algo(1_000_000)
         """
         return AlgoAmount(micro_algo=amount)
 
@@ -141,21 +85,21 @@ class AlgoAmount:
         return f"{self.micro_algo:,} µALGO"
 
     def __int__(self) -> int:
-        return self.micro_algos
+        return self.micro_algo
 
     def __add__(self, other: AlgoAmount) -> AlgoAmount:
         if isinstance(other, AlgoAmount):
-            total_micro_algos = self.micro_algos + other.micro_algos
+            total_micro_algos = self.micro_algo + other.micro_algo
         else:
             raise TypeError(f"Unsupported operand type(s) for +: 'AlgoAmount' and '{type(other).__name__}'")
-        return AlgoAmount.from_micro_algos(total_micro_algos)
+        return AlgoAmount.from_micro_algo(total_micro_algos)
 
     def __radd__(self, other: AlgoAmount) -> AlgoAmount:
         return self.__add__(other)
 
     def __iadd__(self, other: AlgoAmount) -> Self:
         if isinstance(other, AlgoAmount):
-            self.amount_in_micro_algo += other.micro_algos
+            self.amount_in_micro_algo += other.micro_algo
         else:
             raise TypeError(f"Unsupported operand type(s) for +: 'AlgoAmount' and '{type(other).__name__}'")
         return self
@@ -204,42 +148,42 @@ class AlgoAmount:
 
     def __sub__(self, other: AlgoAmount) -> AlgoAmount:
         if isinstance(other, AlgoAmount):
-            total_micro_algos = self.micro_algos - other.micro_algos
+            total_micro_algos = self.micro_algo - other.micro_algo
         else:
             raise TypeError(f"Unsupported operand type(s) for -: 'AlgoAmount' and '{type(other).__name__}'")
-        return AlgoAmount.from_micro_algos(total_micro_algos)
+        return AlgoAmount.from_micro_algo(total_micro_algos)
 
     def __rsub__(self, other: int) -> AlgoAmount:
         if isinstance(other, (int)):
-            total_micro_algos = int(other) - self.micro_algos
-            return AlgoAmount.from_micro_algos(total_micro_algos)
+            total_micro_algos = int(other) - self.micro_algo
+            return AlgoAmount.from_micro_algo(total_micro_algos)
         raise TypeError(f"Unsupported operand type(s) for -: '{type(other).__name__}' and 'AlgoAmount'")
 
     def __isub__(self, other: AlgoAmount) -> Self:
         if isinstance(other, AlgoAmount):
-            self.amount_in_micro_algo -= other.micro_algos
+            self.amount_in_micro_algo -= other.micro_algo
         else:
             raise TypeError(f"Unsupported operand type(s) for -: 'AlgoAmount' and '{type(other).__name__}'")
         return self
 
 
 # Helper functions
-def algo(algos: int) -> AlgoAmount:
+def algo(algo: int) -> AlgoAmount:
     """Create an AlgoAmount object representing the given number of Algo.
 
-    :param algos: The number of Algo to create an AlgoAmount object for.
+    :param algo: The number of Algo to create an AlgoAmount object for.
     :return: An AlgoAmount object representing the given number of Algo.
     """
-    return AlgoAmount.from_algos(algos)
+    return AlgoAmount.from_algo(algo)
 
 
-def micro_algo(microalgos: int) -> AlgoAmount:
+def micro_algo(micro_algo: int) -> AlgoAmount:
     """Create an AlgoAmount object representing the given number of µAlgo.
 
-    :param microalgos: The number of µAlgo to create an AlgoAmount object for.
+    :param micro_algo: The number of µAlgo to create an AlgoAmount object for.
     :return: An AlgoAmount object representing the given number of µAlgo.
     """
-    return AlgoAmount.from_micro_algos(microalgos)
+    return AlgoAmount.from_micro_algo(micro_algo)
 
 
 ALGORAND_MIN_TX_FEE = micro_algo(1_000)
@@ -252,5 +196,5 @@ def transaction_fees(number_of_transactions: int) -> AlgoAmount:
     :return: The total transaction fees.
     """
 
-    total_micro_algos = number_of_transactions * ALGORAND_MIN_TX_FEE.micro_algos
-    return micro_algo(total_micro_algos)
+    total_micro_algos = number_of_transactions * ALGORAND_MIN_TX_FEE.micro_algo
+    return AlgoAmount.from_micro_algo(total_micro_algos)

algokit_utils/models/network.py

@@ -12,11 +12,15 @@ class AlgoClientNetworkConfig:
     {py:class}`algosdk.v2client.indexer.IndexerClient`"""
 
     server: str
-    """URL for the service e.g. `http://localhost:4001` or `https://testnet-api.algonode.cloud`"""
+    """URL for the service e.g. `http://localhost` or `https://testnet-api.algonode.cloud`"""
     token: str | None = None
-    """API Token to authenticate with the service"""
+    """API Token to authenticate with the service e.g '4001' or '8980'"""
     port: str | int | None = None
 
+    def full_url(self) -> str:
+        """Returns the full URL for the service"""
+        return f"{self.server.rstrip('/')}{f':{self.port}' if self.port else ''}"
+
 
 @dataclasses.dataclass
 class AlgoClientConfigs:

algokit_utils/models/transaction.py

@@ -45,7 +45,7 @@ TransactionNote = bytes | TransactionNoteData | Arc2TransactionNote
 TxnTypeT = TypeVar("TxnTypeT", bound=algosdk.transaction.Transaction)
 
 
-class TransactionWrapper(algosdk.transaction.Transaction):
+class TransactionWrapper:
     """Wrapper around algosdk.transaction.Transaction with optional property validators"""
 
     def __init__(self, transaction: algosdk.transaction.Transaction) -> None: