larvaworld.cli.argparser
========================

.. py:module:: larvaworld.cli.argparser


Classes
-------

.. autoapisummary::

   larvaworld.cli.argparser.SingleParserArgument
   larvaworld.cli.argparser.ParserArgumentDict
   larvaworld.cli.argparser.SimModeParser


Module Contents
---------------

.. py:class:: SingleParserArgument(short: str, key: str, **kwargs: Any)

   Create a single parser argument.

   This class is used to populate a parser with arguments and get their values.

   Parameters
   ----------
   short : str
       The short argument name.
   key : str
       The argument key.
   **kwargs : dict
       Additional keyword arguments.

   Attributes
   ----------
   key : str
       The argument key.
   args : list of str
       A list containing the short and long argument names.
   kwargs : dict
       Additional keyword arguments.



   .. py:attribute:: key


   .. py:attribute:: args


   .. py:attribute:: kwargs


   .. py:method:: add(p: argparse.ArgumentParser) -> argparse.ArgumentParser

      Add the argument to a parser.

      Parameters
      ----------
      p : argparse.ArgumentParser
          The argument parser.

      Returns
      -------
      argparse.ArgumentParser
          The modified parser.




   .. py:method:: get(input: argparse.Namespace) -> Any

      Get the value of the argument from parsed input.

      Parameters
      ----------
      input : argparse.Namespace
          The parsed input.

      Returns
      -------
      Any
          The value of the argument.




   .. py:method:: from_dict(name: str, **kwargs: Any) -> SingleParserArgument
      :classmethod:


      Create a SingleParserArgument from a dictionary.

      Parameters
      ----------
      name : str
          The argument name.
      **kwargs : dict
          Additional keyword arguments.

      Returns
      -------
      SingleParserArgument
          A SingleParserArgument instance.




   .. py:method:: from_param(k: str, p: param.Parameter) -> SingleParserArgument
      :classmethod:


      Create a SingleParserArgument from a parameter.

      Parameters
      ----------
      k : str
          The parameter key.
      p : param.Parameter
          The parameter instance.

      Returns
      -------
      SingleParserArgument
          A SingleParserArgument instance.




.. py:class:: ParserArgumentDict(parsargs: larvaworld.lib.util.AttrDict)

   Create a dictionary of parser arguments.

   This class can be instantiated either by a dictionary of param.Parameters or by a dictionary existing in the registry parameter Database.


   .. py:attribute:: parsargs


   .. py:method:: from_param(d0: param.Parameterized) -> ParserArgumentDict
      :classmethod:


      Create a ParserArgumentDict from a parameter dictionary.

      Parameters
      ----------
      d0 : dict
          A dictionary of parameters.

      Returns
      -------
      ParserArgumentDict
          A ParserArgumentDict instance.




   .. py:method:: from_dict(d0: dict) -> ParserArgumentDict
      :classmethod:


      Create a ParserArgumentDict from a dictionary.

      Parameters
      ----------
      d0 : dict
          A dictionary of parser arguments.

      Returns
      -------
      ParserArgumentDict
          A ParserArgumentDict instance.




   .. py:method:: add(parser: argparse.ArgumentParser | None = None) -> argparse.ArgumentParser

      Add parser arguments to an ArgumentParser.

      Parameters
      ----------
      parser : argparse.ArgumentParser, optional
          The ArgumentParser to add the arguments to.

      Returns
      -------
      argparse.ArgumentParser
          The modified ArgumentParser.




   .. py:method:: get(input: argparse.Namespace) -> larvaworld.lib.util.AttrDict

      Get parser argument values from parsed input.

      Parameters
      ----------
      input : argparse.Namespace
          The parsed input.

      Returns
      -------
      dict
          A dictionary of argument values.




.. py:class:: SimModeParser(*args: Any, **kwargs: Any)

   Bases: :py:obj:`argparse.ArgumentParser`


   Parser for simulation modes and arguments.


   .. py:attribute:: parser_dicts


   .. py:method:: init_mode_subparser(sp: argparse.ArgumentParser, m: str) -> argparse.ArgumentParser

      Initialize a subparser with common arguments for a specific simulation mode.

      :param sp: The subparser.
      :param m: The simulation mode.
      :return: The modified subparser.



   .. py:method:: eval_parser(p_key: str, args: argparse.Namespace) -> larvaworld.lib.util.AttrDict

      Evaluate a parser argument.

      :param p_key: The argument key.
      :return: The parsed value of the argument.



   .. py:method:: configure(args: argparse.Namespace) -> tuple[Any, larvaworld.lib.util.AttrDict]

      Configure the simulation run based on parsed arguments.

      :param show_args: Whether to show parsed arguments.
      :return: The configured simulation run.



   .. py:method:: show_args(args: argparse.Namespace, run_kws: larvaworld.lib.util.AttrDict, nested: bool = True, flat_nested: bool = False, input: bool = False) -> None

      Show parsed arguments.

      :param nested: Whether to show arguments as a nested dictionary.
      :param flat_nested: Whether to show arguments as a flattened nested dictionary.
      :param input: Whether to show input arguments.



   .. py:method:: launch(run: Any, args: argparse.Namespace) -> None

      Launch the simulation run.