no listed python and docker installations ways working

[Xyz00777]

Bug description
Nether a newly installed python installation within an python environment or a docker installation is working at the moment out of the box.

Bug not solved
pip install metagpt is not working (tried 40 minutes, with an created environment, i had so mutch log output that it was too long for here but i also tried like 10 additional version overrites and all didnt worked.
https://docs.deepwisdom.ai/main/en/guide/get_started/installation.html#install-stable-version

and all other version from the readme to install it with pip also didnt worked

Environment information

• System version: Nobara Linux 40
• Python version: Python 3.12.7

• installation method: all listed docker and pip instructions on the documentation and readme site.

Screenshots or logs

docker run --rm     --privileged     -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml     -v /opt/metagpt/workspace:/app/metagpt/workspace     metagpt/metagpt:latest     metagpt "Write a cli snake game"            2024-12-02 20:51:33.966 | INFO     | metagpt.const:get_metagpt_package_root:21 - Package root set to /app/metagpt
╭───────────────────── Traceback (most recent call last) ──────────────────────╮
│ /app/metagpt/metagpt/software_company.py:115 in startup                      │
│                                                                              │
│   112 │   │   typer.echo("Missing argument 'IDEA'. Run 'metagpt --help' for  │
│   113 │   │   raise typer.Exit()                                             │
│   114 │                                                                      │
│ ❱ 115 │   return generate_repo(                                              │
│   116 │   │   idea,                                                          │
│   117 │   │   investment,                                                    │
│   118 │   │   n_round,                                                       │
│                                                                              │
│ /app/metagpt/metagpt/software_company.py:31 in generate_repo                 │
│                                                                              │
│    28 │   recover_path=None,                                                 │
│    29 ) -> ProjectRepo:                                                      │
│    30 │   """Run the startup logic. Can be called from CLI or other Python s │
│ ❱  31 │   from metagpt.config2 import config                                 │
│    32 │   from metagpt.context import Context                                │
│    33 │   from metagpt.roles import (                                        │
│    34 │   │   Architect,                                                     │
│                                                                              │
│ /app/metagpt/metagpt/config2.py:169 in <module>                              │
│                                                                              │
│   166 │   return result                                                      │
│   167                                                                        │
│   168                                                                        │
│ ❱ 169 config = Config.default()                                              │
│   170                                                                        │
│                                                                              │
│ /app/metagpt/metagpt/config2.py:109 in default                               │
│                                                                              │
│   106 │   │   ]                                                              │
│   107 │   │                                                                  │
│   108 │   │   dicts = [dict(os.environ)]                                     │
│ ❱ 109 │   │   dicts += [Config.read_yaml(path) for path in default_config_pa │
│   110 │   │   final = merge_dict(dicts)                                      │
│   111 │   │   return Config(**final)                                         │
│   112                                                                        │
│                                                                              │
│ /app/metagpt/metagpt/config2.py:109 in <listcomp>                            │
│                                                                              │
│   106 │   │   ]                                                              │
│   107 │   │                                                                  │
│   108 │   │   dicts = [dict(os.environ)]                                     │
│ ❱ 109 │   │   dicts += [Config.read_yaml(path) for path in default_config_pa │
│   110 │   │   final = merge_dict(dicts)                                      │
│   111 │   │   return Config(**final)                                         │
│   112                                                                        │
│                                                                              │
│ /app/metagpt/metagpt/utils/yaml_model.py:26 in read_yaml                     │
│                                                                              │
│   23 │   │   if not file_path.exists():                                      │
│   24 │   │   │   return {}                                                   │
│   25 │   │   with open(file_path, "r", encoding=encoding) as file:           │
│ ❱ 26 │   │   │   return yaml.safe_load(file)                                 │
│   27 │                                                                       │
│   28 │   @classmethod                                                        │
│   29 │   def from_yaml_file(cls, file_path: Path) -> "YamlModel":            │
│                                                                              │
│ /usr/local/lib/python3.9/site-packages/yaml/__init__.py:125 in safe_load     │
│                                                                              │
│   122 │   Resolve only basic YAML tags. This is known                        │
│   123 │   to be safe for untrusted input.                                    │
│   124 │   """                                                                │
│ ❱ 125 │   return load(stream, SafeLoader)                                    │
│   126                                                                        │
│   127 def safe_load_all(stream):                                             │
│   128 │   """                                                                │
│                                                                              │
│ /usr/local/lib/python3.9/site-packages/yaml/__init__.py:81 in load           │
│                                                                              │
│    78 │   """                                                                │
│    79 │   loader = Loader(stream)                                            │
│    80 │   try:                                                               │
│ ❱  81 │   │   return loader.get_single_data()                                │
│    82 │   finally:                                                           │
│    83 │   │   loader.dispose()                                               │
│    84                                                                        │
│                                                                              │
│ /usr/local/lib/python3.9/site-packages/yaml/constructor.py:49 in             │
│ get_single_data                                                              │
│                                                                              │
│    46 │                                                                      │
│    47 │   def get_single_data(self):                                         │
│    48 │   │   # Ensure that the stream contains a single document and constr │
│ ❱  49 │   │   node = self.get_single_node()                                  │
│    50 │   │   if node is not None:                                           │
│    51 │   │   │   return self.construct_document(node)                       │
│    52 │   │   return None                                                    │
│                                                                              │
│ /usr/local/lib/python3.9/site-packages/yaml/composer.py:36 in                │
│ get_single_node                                                              │
│                                                                              │
│    33 │   │   # Compose a document if the stream is not empty.               │
│    34 │   │   document = None                                                │
│    35 │   │   if not self.check_event(StreamEndEvent):                       │
│ ❱  36 │   │   │   document = self.compose_document()                         │
│    37 │   │                                                                  │
│    38 │   │   # Ensure that the stream contains no more documents.           │
│    39 │   │   if not self.check_event(StreamEndEvent):                       │
│                                                                              │
│ /usr/local/lib/python3.9/site-packages/yaml/composer.py:55 in                │
│ compose_document                                                             │
│                                                                              │
│    52 │   │   self.get_event()                                               │
│    53 │   │                                                                  │
│    54 │   │   # Compose the root node.                                       │
│ ❱  55 │   │   node = self.compose_node(None, None)                           │
│    56 │   │                                                                  │
│    57 │   │   # Drop the DOCUMENT-END event.                                 │
│    58 │   │   self.get_event()                                               │
│                                                                              │
│ /usr/local/lib/python3.9/site-packages/yaml/composer.py:84 in compose_node   │
│                                                                              │
│    81 │   │   elif self.check_event(SequenceStartEvent):                     │
│    82 │   │   │   node = self.compose_sequence_node(anchor)                  │
│    83 │   │   elif self.check_event(MappingStartEvent):                      │
│ ❱  84 │   │   │   node = self.compose_mapping_node(anchor)                   │
│    85 │   │   self.ascend_resolver()                                         │
│    86 │   │   return node                                                    │
│    87                                                                        │
│                                                                              │
│ /usr/local/lib/python3.9/site-packages/yaml/composer.py:127 in               │
│ compose_mapping_node                                                         │
│                                                                              │
│   124 │   │   │   │   flow_style=start_event.flow_style)                     │
│   125 │   │   if anchor is not None:                                         │
│   126 │   │   │   self.anchors[anchor] = node                                │
│ ❱ 127 │   │   while not self.check_event(MappingEndEvent):                   │
│   128 │   │   │   #key_event = self.peek_event()                             │
│   129 │   │   │   item_key = self.compose_node(node, None)                   │
│   130 │   │   │   #if item_key in node.value:                                │
│                                                                              │
│ /usr/local/lib/python3.9/site-packages/yaml/parser.py:98 in check_event      │
│                                                                              │
│    95 │   │   # Check the type of the next event.                            │
│    96 │   │   if self.current_event is None:                                 │
│    97 │   │   │   if self.state:                                             │
│ ❱  98 │   │   │   │   self.current_event = self.state()                      │
│    99 │   │   if self.current_event is not None:                             │
│   100 │   │   │   if not choices:                                            │
│   101 │   │   │   │   return True                                            │
│                                                                              │
│ /usr/local/lib/python3.9/site-packages/yaml/parser.py:438 in                 │
│ parse_block_mapping_key                                                      │
│                                                                              │
│   435 │   │   │   │   return self.process_empty_scalar(token.end_mark)       │
│   436 │   │   if not self.check_token(BlockEndToken):                        │
│   437 │   │   │   token = self.peek_token()                                  │
│ ❱ 438 │   │   │   raise ParserError("while parsing a block mapping", self.ma │
│   439 │   │   │   │   │   "expected <block end>, but found %r" % token.id, t │
│   440 │   │   token = self.get_token()                                       │
│   441 │   │   event = MappingEndEvent(token.start_mark, token.end_mark)      │
╰──────────────────────────────────────────────────────────────────────────────╯
ParserError: while parsing a block mapping
  in "/app/metagpt/config/config2.yaml", line 1, column 1
expected <block end>, but found '<block mapping start>'
  in "/app/metagpt/config/config2.yaml", line 5, column 3

[shenchucheng]

The error suggests there is a syntax issue in your config2.yaml file.

[Xyz00777]

wow okay that worked, fail :D
but still the python way didnt worked...

[shenchucheng]

Are there any other errors?

[github-actions]

This issue has no activity in the past 30 days. Please comment on the issue if you have anything to add.