scml.utils ========== .. py:module:: scml.utils Attributes ---------- .. autoapisummary:: scml.utils.DefaultAgentsOneShot scml.utils.DefaultAgentsStd scml.utils.DefaultAgents scml.utils.DefaultAgents2021 scml.utils.DefaultAgents2022 scml.utils.DefaultAgents2023 scml.utils.anac_config_generator_std_old scml.utils.anac_assigner_oneshot Functions --------- .. autoapisummary:: scml.utils.anac_config_generator_oneshot scml.utils.anac_config_generator_std_new scml.utils.anac_config_generator_collusion scml.utils.anac_assigner_std scml.utils.anac_assigner_collusion scml.utils.anac_world_generator scml.utils.anac_oneshot_world_generator scml.utils.balance_calculator scml.utils.balance_calculator_oneshot scml.utils.anac2020_tournament scml.utils.anac2020_std scml.utils.anac2020_collusion scml.utils.anac2021_std scml.utils.anac2021_collusion scml.utils.anac2021_oneshot scml.utils.anac2022_std scml.utils.anac2022_collusion scml.utils.anac2022_oneshot scml.utils.anac2023_collusion scml.utils.anac2023_std scml.utils.anac2023_oneshot scml.utils.anac2024_oneshot scml.utils.anac2024_std Module Contents --------------- .. py:data:: DefaultAgentsOneShot .. py:data:: DefaultAgentsStd .. py:data:: DefaultAgents :type: tuple[type[scml.scml2020.world.SCML2020Agent], Ellipsis] .. py:data:: DefaultAgents2021 .. py:data:: DefaultAgents2022 .. py:data:: DefaultAgents2023 .. py:data:: anac_config_generator_std_old .. py:function:: anac_config_generator_oneshot(*args, **kwargs) .. py:function:: anac_config_generator_std_new(*args, **kwargs) .. py:function:: anac_config_generator_collusion(year: int, n_competitors: int, n_agents_per_competitor: int, agent_names_reveal_type: bool = False, non_competitors: tuple[str | type[scml.scml2020.world.SCML2020Agent], Ellipsis] | None = None, non_competitor_params: tuple[dict[str, Any], Ellipsis] | None = None, *args, **kwargs) -> list[dict[str, Any]] .. py:function:: anac_assigner_std(config: list[dict[str, Any]], max_n_worlds: int, n_agents_per_competitor: int = 1, fair: bool = True, competitors: Sequence[str | type[scml.oneshot.agent.OneShotAgent] | type[negmas.Agent]] = (), params: Sequence[dict[str, Any]] | None = (), dynamic_non_competitors: Sequence[str | type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = True) -> list[list[dict[str, Any]]] .. py:data:: anac_assigner_oneshot .. py:function:: anac_assigner_collusion(config: list[dict[str, Any]], max_n_worlds: int, n_agents_per_competitor: int = 1, fair: bool = True, competitors: Sequence[type[negmas.Agent] | str] = (), params: Sequence[dict[str, Any]] | None = (), dynamic_non_competitors: list[type[negmas.Agent] | str] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = True) -> list[list[dict[str, Any]]] .. py:function:: anac_world_generator(*, year: int, **kwargs) .. py:function:: anac_oneshot_world_generator(*, year, **kwargs) .. py:function:: balance_calculator(worlds: list[scml.scml2020.world.SCML2020World], scoring_context: dict[str, Any], dry_run: bool, ignore_default=True, inventory_catalog_price_weight=0.0, inventory_trading_average_weight=0.5, consolidated=False) -> negmas.tournaments.WorldRunResults A scoring function that scores factory managers' performance by the final balance only ignoring whatever still in their inventory. :param worlds: The world which is assumed to be run up to the point at which the scores are to be calculated. :param scoring_context: A dict of context parameters passed by the world generator or assigner. :param dry_run: A boolean specifying whether this is a dry_run. For dry runs, only names and types are expected in the returned `WorldRunResults` :param ignore_default: Whether to ignore non-competitors (default agents) :param inventory_catalog_price_weight: The weight assigned to catalog price :param inventory_trading_average_weight: The weight assigned to trading price average :param consolidated: If true, the score of an agent type will be based on a consolidated statement of all the factories it controlled :returns: WorldRunResults giving the names, scores, and types of factory managers. .. py:function:: balance_calculator_oneshot(worlds: list[scml.oneshot.world.OneShotWorld], scoring_context: dict[str, Any], dry_run: bool, ignore_default=True, consolidated=True, **kwargs) -> negmas.tournaments.WorldRunResults A scoring function that scores factory managers' performance by the final balance only ignoring whatever still in their inventory. :param worlds: The world which is assumed to be run up to the point at which the scores are to be calculated. :param scoring_context: A dict of context parameters passed by the world generator or assigner. :param dry_run: A boolean specifying whether this is a dry_run. For dry runs, only names and types are expected in the returned `WorldRunResults` :param ignore_default: Whether to ignore non-competitors (default agents) :param consolidated: If true, the score of an agent type will be based on a consolidated statement of all the factories it controlled :returns: WorldRunResults giving the names, scores, and types of factory managers. .. py:function:: anac2020_tournament(competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]], agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 2, n_agents_per_competitor: int = 3, min_factories_per_level: int = 2, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2020 SCML tournament (collusion track). :param name: Tournament name :param competitors: A list of class names for the competitors :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (by rotating agents over factories). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param n_agents_per_competitor: Number of agents per competitor :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, effort will be made to reduce memory footprint including disableing most logs :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2020_std(competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, min_factories_per_level: int = 2, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = True, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2020 SCML tournament (standard track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2020_collusion(competitors: Sequence[str | type], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, n_agents_per_competitor: int = 3, min_factories_per_level: int = 2, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = True, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2020 SCML tournament (collusion track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param n_agents_per_competitor: Number of agents per competitor :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2021_std(competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, min_factories_per_level: int = 2, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = True, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2021 SCML tournament (standard track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2021_collusion(competitors: Sequence[str | type], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, n_agents_per_competitor: int = 3, min_factories_per_level: int = 2, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = False, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=1, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2021 SCML tournament (collusion track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param n_agents_per_competitor: Number of agents per competitor :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors. This value will always be set to 1 in SCML2021 :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2021_oneshot(competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, min_factories_per_level: int = 4, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = False, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2021 SCML tournament (oneshot track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2022_std(competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, min_factories_per_level: int = 2, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = True, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2022 SCML tournament (standard track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2022_collusion(competitors: Sequence[str | type], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, n_agents_per_competitor: int = 3, min_factories_per_level: int = 2, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = False, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=1, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2022 SCML tournament (collusion track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param n_agents_per_competitor: Number of agents per competitor :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors. This value will always be set to 1 in SCML2022 :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2022_oneshot(competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, min_factories_per_level: int = 4, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = False, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2022 SCML tournament (oneshot track). Args: :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2023_collusion(competitors: Sequence[str | type], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, n_agents_per_competitor: int = 3, min_factories_per_level: int = 2, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = False, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=1, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2023 SCML tournament (collusion track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param n_agents_per_competitor: Number of agents per competitor :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors. This value will always be set to 1 in SCML2022 :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2023_std(competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, min_factories_per_level: int = 2, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = True, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2023 SCML tournament (standard track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2023_oneshot(competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, min_factories_per_level: int = 4, tournament_path: str | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.scml2020.world.SCML2020World | None], None] | None = None, non_competitors: Sequence[str | type[scml.scml2020.world.SCML2020Agent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = False, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2023 SCML tournament (oneshot track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2024_oneshot(competitors: Sequence[str | type[scml.oneshot.agent.OneShotAgent]], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, min_factories_per_level: int = 4, tournament_path: str | pathlib.Path | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.oneshot.world.SCML2024OneShotWorld | None], None] | None = None, non_competitors: Sequence[str | type[scml.oneshot.agent.OneShotAgent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[scml.oneshot.agent.OneShotAgent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = False, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, context=None, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2024 SCML tournament (oneshot track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing .. py:function:: anac2024_std(competitors: Sequence[str | type[scml.std.agent.StdAgent]], competitor_params: Sequence[dict[str, Any]] | None = None, agent_names_reveal_type=False, n_configs: int = 5, max_worlds_per_config: int | None = None, n_runs_per_world: int = 1, min_factories_per_level: int = 4, tournament_path: str | pathlib.Path | pathlib.Path | None = None, total_timeout: int | None = None, parallelism='parallel', scheduler_ip: str | None = None, scheduler_port: str | None = None, tournament_progress_callback: Callable[[negmas.tournaments.WorldRunResults | None], None] | None = None, world_progress_callback: Callable[[scml.oneshot.world.SCML2024OneShotWorld | None], None] | None = None, non_competitors: Sequence[str | type[scml.oneshot.agent.OneShotAgent]] | None = None, non_competitor_params: Sequence[dict[str, Any]] | None = None, dynamic_non_competitors: list[type[negmas.Agent]] | None = None, dynamic_non_competitor_params: list[dict[str, Any]] | None = None, exclude_competitors_from_reassignment: bool = False, name: str | None = None, verbose: bool = False, configs_only=False, compact=False, n_competitors_per_world=None, forced_logs_fraction: float = FORCED_LOGS_FRACTION, context=None, **kwargs) -> negmas.tournaments.TournamentResults | os.PathLike The function used to run ANAC 2024 SCML tournament (std track). :param name: Tournament name :param competitors: A list of class names for the competitors :param competitor_params: A list of competitor parameters (used to initialize the competitors). :param agent_names_reveal_type: If true then the type of an agent should be readable in its name (most likely at its beginning). :param n_configs: The number of different world configs (up to competitor assignment) to be generated. :param max_worlds_per_config: The maximum number of worlds to run per config. If None, then all possible assignments of competitors within each config will be tried (all permutations). :param n_runs_per_world: Number of runs per world. All of these world runs will have identical competitor assignment and identical world configuration. :param min_factories_per_level: Minimum number of factories for each production level :param total_timeout: Total timeout for the complete process :param tournament_path: Path at which to store all results. A scores.csv file will keep the scores and logs folder will keep detailed logs :param parallelism: Type of parallelism. Can be 'serial' for serial, 'parallel' for parallel and 'distributed' for distributed :param scheduler_port: Port of the dask scheduler if parallelism is dask, dist, or distributed :param scheduler_ip: IP Address of the dask scheduler if parallelism is dask, dist, or distributed :param world_progress_callback: A function to be called after everystep of every world run (only allowed for serial evaluation and should be used with cautious). :param tournament_progress_callback: A function to be called with `WorldRunResults` after each world finished processing :param non_competitors: A list of agent types that will not be competing in the sabotage competition but will exist in the world :param non_competitor_params: parameters of non competitor agents :param dynamic_non_competitors: A list of non-competing agents that are assigned to the simulation dynamically during the creation of the final assignment instead when the configuration is created :param dynamic_non_competitor_params: paramters of dynamic non competitor agents :param exclude_competitors_from_reassignment: If true, competitors are excluded from the dynamic non-competitors :param verbose: Verbosity :param configs_only: If true, a config file for each :param compact: If true, compact logs will be created and effort will be made to reduce the memory footprint :param n_competitors_per_world: Number of competitors in every simulation. If not given it will be a random number between 2 and min(2, n), where n is the number of competitors :param forced_logs_fraction: Fraction of simulations for which logs are always saved (including negotiations) :param kwargs: Arguments to pass to the `world_generator` function :returns: `TournamentResults` The results of the tournament or a `PathLike` giving the location where configs were saved Remarks: Default parameters will be used in the league with the exception of `parallelism` which may use distributed processing