Update src/converter/code_generator_fixed.py

docs/ComprehensiveCodeAnalysisReport.md

@@ -0,0 +1,122 @@
+# Comprehensive Code Analysis Report
+
+## Top-Level Files
+
+### `./README.md`
+*   **Purpose**: Main entry point for project information, setup, usage.
+*   **Completion Status/Key Observations**: Largely up-to-date with recent "Sprint 2" achievements (class support, Union types). Details installation, usage for simple and class examples, output structure, and basic project structure. Mentions supported features and areas for development.
+*   **Key Relations**: Links to LICENSE, references `requirements.txt`, `examples/`, `src/main.py`.
+*   **Potential Enhancements/Improvements**:
+    *   Explicitly state that `class_example.py` is the primary example for current advanced features.
+    *   Link to or summarize key findings from `docs/` for a fuller picture of limitations.
+
+### `./requirements.txt`
+*   **Purpose**: Lists Python dependencies.
+*   **Completion Status/Key Observations**: Contains standard tools for analysis, testing, formatting (`astroid`, `pylint`, `mypy`, `pytest`, `black`, `networkx`, `typing-extensions`). Appears complete for current needs.
+*   **Key Relations**: Used in `CONTRIBUTING.md` for setup, essential for development environment.
+*   **Potential Enhancements/Improvements**: Consider version pinning for more reproducible builds if issues arise.
+
+### `./CONTRIBUTING.md`
+*   **Purpose**: Provides guidelines for contributing to the project.
+*   **Completion Status/Key Observations**: Outlines setup, coding standards (Black, Pylint, Mypy), testing procedures, and commit message format. Appears comprehensive.
+*   **Key Relations**: References `requirements.txt`, `tox.ini`.
+*   **Potential Enhancements/Improvements**: None apparent at this time.
+
+### `./LICENSE`
+*   **Purpose**: Specifies the legal terms under which the project is distributed.
+*   **Completion Status/Key Observations**: Uses the MIT License, a permissive open-source license.
+*   **Key Relations**: Referenced in `README.md`.
+*   **Potential Enhancements/Improvements**: None.
+
+### `./tox.ini`
+*   **Purpose**: Configuration file for tox, an automation tool for Python testing.
+*   **Completion Status/Key Observations**: Defines test environments for linting (Pylint, Mypy, Black) and unit testing (pytest). Includes commands and dependencies for each environment.
+*   **Key Relations**: Used by `tox` for automated testing and linting. Crucial for CI/CD.
+*   **Potential Enhancements/Improvements**: Could be expanded with more specific test targets or coverage analysis.
+
+### `./.gitignore`
+*   **Purpose**: Specifies intentionally untracked files that Git should ignore.
+*   **Completion Status/Key Observations**: Includes common Python-related files/directories (`__pycache__`, `*.pyc`, `.env`), virtual environment directories (`venv`, `env`), build artifacts (`dist`, `build`), and IDE-specific files. Seems well-configured.
+*   **Key Relations**: Standard Git configuration file.
+*   **Potential Enhancements/Improvements**: None apparent.
+
+## `src/` Directory
+
+### `src/main.py`
+*   **Purpose**: Main executable script for the Python to DOT graph conversion. Handles command-line arguments, file processing, and DOT graph generation.
+*   **Completion Status/Key Observations**: Core logic for parsing Python code using `astroid`, building a graph with `networkx`, and outputting DOT format. Supports basic types, functions, classes, and modules. Recent additions include handling of Union types and improved class member representation.
+*   **Key Relations**: Uses `astroid` for AST parsing, `networkx` for graph representation. Interacts with `src/output_graphs.py`. Reads Python files from `examples/`.
+*   **Potential Enhancements/Improvements**:
+    *   Refactor large functions for better modularity.
+    *   Enhance error handling for malformed Python inputs.
+    *   Add support for more complex type hints and Python features.
+
+### `src/output_graphs.py`
+*   **Purpose**: Responsible for generating the DOT language output from the `networkx` graph.
+*   **Completion Status/Key Observations**: Contains functions to format nodes and edges according to DOT syntax, including styling for different Python constructs (classes, functions, modules, variables, types).
+*   **Key Relations**: Consumes `networkx` graph objects generated by `src/main.py`.
+*   **Potential Enhancements/Improvements**:
+    *   Offer more customization options for graph appearance (colors, shapes).
+    *   Support different output formats beyond DOT (e.g., GML, GraphML).
+
+## `examples/` Directory
+
+### `examples/simple_example.py`
+*   **Purpose**: Provides a basic Python script for demonstrating the tool's functionality with simple functions, variables, and type hints.
+*   **Completion Status/Key Observations**: Contains straightforward examples of global variables, functions with typed arguments and return values.
+*   **Key Relations**: Used as an input for `src/main.py` for testing and demonstration.
+*   **Potential Enhancements/Improvements**: Could include a slightly more complex function or a basic class to showcase more features.
+
+### `examples/class_example.py`
+*   **Purpose**: Demonstrates the tool's capabilities with Python classes, including methods, attributes, inheritance, and Union type hints.
+*   **Completion Status/Key Observations**: Contains classes with constructors, methods (with `self`), class variables, instance variables, and inheritance. Uses `Union` and `Optional` type hints. This is the primary example for current advanced features.
+*   **Key Relations**: Used as a key input for `src/main.py` for testing class-related feature support.
+*   **Potential Enhancements/Improvements**: Add examples of multiple inheritance or more complex class interactions if those features are further developed.
+
+### `examples/module_example/`
+*   **Purpose**: Directory containing multiple Python files (`module1.py`, `module2.py`) to demonstrate inter-module dependencies and imports.
+*   **Completion Status/Key Observations**: `module1.py` defines functions and classes, `module2.py` imports and uses them.
+*   **Key Relations**: Shows how `src/main.py` handles imports and represents module relationships in the graph.
+*   **Potential Enhancements/Improvements**: Could include more complex import scenarios (e.g., `from ... import ... as ...`, wildcard imports if supported).
+
+## `tests/` Directory
+
+### `tests/test_main.py`
+*   **Purpose**: Contains unit tests for the core functionality in `src/main.py`.
+*   **Completion Status/Key Observations**: Uses `pytest`. Tests cover graph generation for simple types, functions, classes, and basic module imports. Mocks file system operations and `astroid` parsing where necessary. Checks for expected nodes and edges in the generated `networkx` graph.
+*   **Key Relations**: Tests the logic within `src/main.py`. Relies on example files in `examples/` as input for some tests.
+*   **Potential Enhancements/Improvements**:
+    *   Increase test coverage, especially for error conditions and edge cases.
+    *   Add tests for newly supported features (e.g., specific Union type scenarios).
+    *   Test DOT output validation more rigorously if `src/output_graphs.py` becomes more complex.
+
+## `docs/` Directory
+
+### `docs/DevelopmentLog.md`
+*   **Purpose**: Tracks development progress, decisions, and future plans.
+*   **Completion Status/Key Observations**: Contains entries for "Sprint 1" and "Sprint 2", detailing features implemented (basic types, functions, classes, Union types, module handling), bugs fixed, and next steps.
+*   **Key Relations**: Internal development document.
+*   **Potential Enhancements/Improvements**: Maintain regular updates as development progresses.
+
+### `docs/Limitations.md`
+*   **Purpose**: Documents known limitations and unsupported features of the tool.
+*   **Completion Status/Key Observations**: Lists issues like lack of support for decorators, generators, context managers, advanced `typing` features (Generics, Protocols), and dynamic aspects of Python.
+*   **Key Relations**: Important for users to understand the current scope of the tool.
+*   **Potential Enhancements/Improvements**: Update as new limitations are discovered or existing ones are addressed.
+
+### `docs/sprint2_notes.md`
+*   **Purpose**: Contains detailed notes and findings from the "Sprint 2" development cycle, focusing on class and Union type support.
+*   **Completion Status/Key Observations**: Records observations about `astroid` behavior with classes, methods, attributes, inheritance, and Union types. Discusses how to represent these in the graph.
+*   **Key Relations**: Informal notes supporting `DevelopmentLog.md` and guiding implementation in `src/main.py`.
+*   **Potential Enhancements/Improvements**: Key insights should be summarized and moved to more permanent documentation like `DevelopmentLog.md` or design documents if they exist.
+
+## `generated/` Directory
+
+### `generated/example_graphs/`
+*   **Purpose**: Stores the output DOT graph files generated by `src/main.py` when run on the example Python scripts.
+*   **Completion Status/Key Observations**: Contains `.dot` files like `simple_example.dot`, `class_example.dot`, `module_example.dot`. These serve as visual references and can be used for regression testing (though not formally done yet).
+*   **Key Relations**: Outputs of `src/main.py` using inputs from `examples/`.
+*   **Potential Enhancements/Improvements**:
+    *   Implement automated visual diffing or structural comparison of DOT files for regression testing.
+    *   Ensure graphs are kept up-to-date with code changes.
+```

src/analyzer/code_analyzer.py

@@ -94,6 +94,9 @@ def _analyze_complexity(self, tree: ast.AST) -> None:
 
     def _infer_variable_type(self, node: ast.Assign) -> None:
         """Infer the type of a variable assignment."""
+        if isinstance(node.targets[0], ast.Tuple):
+            self._handle_tuple_target_assignment(node)
+            return
         # Basic type inference implementation
         if isinstance(node.value, ast.Constant):
             if isinstance(node.value.value, (int, float)):
@@ -210,6 +213,67 @@ def _infer_variable_type(self, node: ast.Assign) -> None:
                     else:
                         self.type_info[target.id] = 'int'
 
+    def _handle_tuple_target_assignment(self, node: ast.Assign) -> None:
+        """Handle tuple unpacking in assignments."""
+        target_tuple = node.targets[0]
+
+        if isinstance(node.value, ast.Call):
+            if isinstance(node.value.func, ast.Name):
+                func_name = node.value.func.id
+                if func_name in self.type_info:
+                    return_type = self.type_info[func_name].get('return_type', None)
+                    if return_type and isinstance(return_type, str) and return_type.startswith('std::tuple<'):
+                        types = return_type[11:-1].split(', ')
+                        for i, target in enumerate(target_tuple.elts):
+                            if i < len(types):
+                                if isinstance(target, ast.Tuple):
+                                    if types[i].startswith('std::tuple<'):
+                                        nested_types = types[i][11:-1].split(', ')
+                                        for j, nested_target in enumerate(target.elts):
+                                            if j < len(nested_types) and isinstance(nested_target, ast.Name):
+                                                self.type_info[nested_target.id] = nested_types[j]
+                                            elif isinstance(nested_target, ast.Name):
+                                                self.type_info[nested_target.id] = 'int'
+                                    else:
+                                        for nested_target in target.elts:
+                                            if isinstance(nested_target, ast.Name):
+                                                self.type_info[nested_target.id] = 'int'
+                                elif isinstance(target, ast.Name):
+                                    self.type_info[target.id] = types[i]
+                            elif isinstance(target, ast.Name):
+                                self.type_info[target.id] = 'int'
+                    else:
+                        self._assign_default_types_to_tuple(target_tuple)
+                else:
+                    self._assign_default_types_to_tuple(target_tuple)
+            else:
+                self._assign_default_types_to_tuple(target_tuple)
+        elif isinstance(node.value, ast.Tuple):
+            for target, value in zip(target_tuple.elts, node.value.elts):
+                if isinstance(target, ast.Tuple):
+                    if isinstance(value, ast.Tuple):
+                        for nested_target, nested_value in zip(target.elts, value.elts):
+                            if isinstance(nested_target, ast.Name):
+                                self.type_info[nested_target.id] = self._infer_expression_type(nested_value)
+                    else:
+                        for nested_target in target.elts:
+                            if isinstance(nested_target, ast.Name):
+                                self.type_info[nested_target.id] = 'int'
+                elif isinstance(target, ast.Name):
+                    self.type_info[target.id] = self._infer_expression_type(value)
+        else:
+            self._assign_default_types_to_tuple(target_tuple)
+
+    def _assign_default_types_to_tuple(self, target_tuple: ast.Tuple) -> None:
+        """Assign default types to all elements in a tuple unpacking."""
+        for target in target_tuple.elts:
+            if isinstance(target, ast.Tuple):
+                for nested_target in target.elts:
+                    if isinstance(nested_target, ast.Name):
+                        self.type_info[nested_target.id] = 'int'
+            elif isinstance(target, ast.Name):
+                self.type_info[target.id] = 'int'
+
     def _infer_expression_type(self, node: ast.AST) -> str:
         """Infer the type of an expression."""
         print(f"Inferring expression type for: {type(node)}")

src/analyzer/code_analyzer_fixed.py

@@ -298,9 +298,9 @@ def _infer_variable_type(self, node: ast.Assign) -> None:
             if node.value.keys and node.value.values:
                 key_type = self._infer_expression_type(node.value.keys[0])
                 value_type = self._infer_expression_type(node.value.values[0])
-                self._store_type_for_target(node.targets[0], f'std::map<{key_type}, {value_type}>')
+                self._store_type_for_target(node.targets[0], f'std::unordered_map<{key_type}, {value_type}>')
             else:
-                self._store_type_for_target(node.targets[0], 'std::map<std::string, int>')  # Default
+                self._store_type_for_target(node.targets[0], 'std::unordered_map<std::string, int>')  # Default
         elif isinstance(node.value, ast.Set):
             # Try to infer set element type
             if node.value.elts:
@@ -352,7 +352,7 @@ def _infer_variable_type(self, node: ast.Assign) -> None:
                     elif func_name == 'list':
                         self._store_type_for_target(node.targets[0], 'std::vector<int>')
                     elif func_name == 'dict':
-                        self._store_type_for_target(node.targets[0], 'std::map<std::string, int>')
+                        self._store_type_for_target(node.targets[0], 'std::unordered_map<std::string, int>')
                     elif func_name == 'set':
                         self._store_type_for_target(node.targets[0], 'std::set<int>')
                     else:
@@ -478,8 +478,8 @@ def _infer_expression_type(self, node: ast.AST) -> str:
             if node.keys and node.values:
                 key_type = self._infer_expression_type(node.keys[0])
                 value_type = self._infer_expression_type(node.values[0])
-                return f'std::map<{key_type}, {value_type}>'
-            return 'std::map<std::string, int>'
+                return f'std::unordered_map<{key_type}, {value_type}>'
+            return 'std::unordered_map<std::string, int>'
         elif isinstance(node, ast.Set):
             if node.elts:
                 elt_type = self._infer_expression_type(node.elts[0])
@@ -542,7 +542,7 @@ def _infer_expression_type(self, node: ast.AST) -> str:
                 elif func_name == 'list':
                     return 'std::vector<int>'
                 elif func_name == 'dict':
-                    return 'std::map<std::string, int>'
+                    return 'std::unordered_map<std::string, int>'
                 elif func_name == 'set':
                     return 'std::set<int>'
                 elif func_name == 'tuple':
@@ -566,9 +566,9 @@ def _infer_expression_type(self, node: ast.AST) -> str:
                     if isinstance(type_info, str):
                         if type_info.startswith('std::vector<'):
                             return type_info[12:-1]  # Extract T from std::vector<T>
-                        elif type_info.startswith('std::map<'):
-                            # Return value type from std::map<K, V>
-                            parts = type_info[9:-1].split(', ')
+                        elif type_info.startswith('std::unordered_map<'):
+                            # Return value type from std::unordered_map<K, V>
+                            parts = type_info[18:-1].split(', ')
                             if len(parts) > 1:
                                 return parts[1]
                         elif type_info.startswith('std::tuple<'):
@@ -581,9 +581,9 @@ def _infer_expression_type(self, node: ast.AST) -> str:
             value_type = self._infer_expression_type(node.value)
             if value_type.startswith('std::vector<'):
                 return value_type[12:-1]  # Extract T from std::vector<T>
-            elif value_type.startswith('std::map<'):
-                # Return value type from std::map<K, V>
-                parts = value_type[9:-1].split(', ')
+            elif value_type.startswith('std::unordered_map<'):
+                # Return value type from std::unordered_map<K, V>
+                parts = value_type[18:-1].split(', ')
                 if len(parts) > 1:
                     return parts[1]
             return 'int'  # Default type
@@ -693,10 +693,10 @@ def _get_type_name(self, node: ast.AST) -> str:
                     if isinstance(elt, ast.Tuple) and len(elt.elts) >= 2:
                         key_type = self._get_type_name(elt.elts[0])
                         value_type = self._get_type_name(elt.elts[1])
-                        return f'std::map<{key_type}, {value_type}>'
+                        return f'std::unordered_map<{key_type}, {value_type}>'
                     else:
                         # Default if not a proper tuple
-                        return 'std::map<std::string, int>'
+                        return 'std::unordered_map<std::string, int>'
                 elif base_type == 'set' or base_type == 'Set':
                     inner_type = self._get_type_name(elt)
                     return f'std::set<{inner_type}>'