cod8a 0.1.0__py3-none-any.whl

cod8a/models/models.py

@@ -0,0 +1,60 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+from pydantic.dataclasses import dataclass
+
+@dataclass
+class UsingDirective:
+    id: int
+    name: str
+
+@dataclass
+class ParameterStructure:
+    name: str
+    modifier: str
+    type: str
+    summary: str
+
+@dataclass
+class FieldStructure:
+    id: int
+    name: str
+    modifier: str
+    type: str
+    summary: str
+
+@dataclass
+class MethodStructure:
+    id: int
+    name: str
+    modifier: str
+    return_type: str
+    parameters: List[ParameterStructure]
+    summary: str
+
+@dataclass
+class Relationship:
+    id: int
+    type: str
+    parent_name: str
+
+@dataclass
+class ClassStructure:
+    id: int
+    name: str
+    methods: List[MethodStructure]
+    fields: List[FieldStructure]
+    type: str
+    associated_item: List[Relationship]
+    summary: str
+
+class FileStructure(BaseModel):
+    id: int
+    name: str
+    using_directives: Optional[List[UsingDirective]] = []
+    classes: Optional[List[ClassStructure]] = []
+
+
+class ProjectStructure(BaseModel):
+    name: str
+    files: List[FileStructure] = []

cod8a/parsers/dotnet_parser.py

@@ -0,0 +1,100 @@
+import subprocess
+import json
+import os
+import shutil
+from typing import Union, List
+from cod8a.models.models import (
+    FileStructure, ProjectStructure, ClassStructure, 
+    MethodStructure, FieldStructure, ParameterStructure, 
+    UsingDirective, Relationship
+)
+
+class DotnetParser:
+    def __init__(self, analyzer_path: str):
+        self.analyzer_path = analyzer_path
+
+    def parse(self, path: str) -> Union[FileStructure, ProjectStructure]:
+        if not shutil.which("dotnet"):
+            raise Exception("The .NET SDK/Runtime is required to analyze C# files. Please install it or ensure it is in your PATH.")
+
+        abs_path = os.path.abspath(path)
+        cwd = os.path.dirname(self.analyzer_path)
+        
+        # Look for a compiled DLL first (production/distribution mode)
+        # Expected path: src/cod8a/dotnet/CodeAnalysis/bin/Release/net10.0/CodeAnalyzer.dll
+        dll_path = os.path.join(cwd, "bin", "Release", "net10.0", "CodeAnalyzer.dll")
+        
+        if os.path.exists(dll_path):
+            args = ["dotnet", dll_path, abs_path]
+        else:
+            # Fallback to source-level execution (development mode)
+            args = ["dotnet", "run", "--project", self.analyzer_path, "--", abs_path]
+
+        result = subprocess.run(args, capture_output=True, text=True, cwd=cwd)
+        if result.returncode != 0:
+            raise Exception(f"Dotnet analyzer failed: {result.stderr}")
+
+        # The C# analyzer might still print some messages to stdout. 
+        # We find the last line which should be our JSON.
+        lines = result.stdout.strip().splitlines()
+        json_str = next((line for line in reversed(lines) if line.startswith('{') and line.endswith('}')), None)
+        
+        if not json_str:
+            raise Exception(f"Could not find JSON in dotnet analyzer output: {result.stdout}")
+
+        data = json.loads(json_str)
+        
+        if "Files" in data:
+            return self._map_project(data)
+        return self._map_file(data)
+
+    def _map_project(self, data: dict) -> ProjectStructure:
+        return ProjectStructure(
+            name=data.get("Name", ""),
+            files=[self._map_file(f) for f in data.get("Files", [])]
+        )
+
+    def _map_file(self, data: dict) -> FileStructure:
+        return FileStructure(
+            id=data.get("Id", 0),
+            name=data.get("Name", ""),
+            using_directives=[UsingDirective(u.get("Id", 0), u.get("Name", "")) for u in data.get("UsingDirectives", []) or []],
+            classes=[self._map_class(c) for c in data.get("Classes", []) or []],
+        )
+
+    def _map_class(self, data: dict) -> ClassStructure:
+        return ClassStructure(
+            id=data.get("Id", 0),
+            name=data.get("Name", ""),
+            methods=[self._map_method(m) for m in data.get("Methods", []) or []],
+            fields=[self._map_field(f) for f in data.get("Fields", []) or []],
+            type=data.get("Type", "class"),
+            associated_item=[self._map_relationship(r) for r in data.get("Relationships", []) or []],
+            summary=data.get("Summary", "")
+        )
+
+    def _map_method(self, data: dict) -> MethodStructure:
+        return MethodStructure(
+            id=data.get("Id", 0),
+            name=data.get("Name", ""),
+            modifier=data.get("Modifier", ""),
+            return_type=data.get("ReturnType", ""),
+            parameters=[ParameterStructure(p.get("Name", ""), p.get("Modifier", ""), p.get("Type", ""), p.get("Summary", "")) for p in data.get("Parameters", []) or []],
+            summary=data.get("Summary", "")
+        )
+
+    def _map_field(self, data: dict) -> FieldStructure:
+        return FieldStructure(
+            id=data.get("Id", 0),
+            name=data.get("Name", ""),
+            modifier=data.get("Modifier", ""),
+            type=data.get("Type", ""),
+            summary=data.get("Summary", "")
+        )
+
+    def _map_relationship(self, data: dict) -> Relationship:
+        return Relationship(
+            id=data.get("Id", 0),
+            type=data.get("Type", ""),
+            parent_name=data.get("AssociatedItem", "")
+        )

cod8a/parsers/python_parser.py

@@ -0,0 +1,138 @@
+import ast
+import json
+import os
+from typing import List, Union
+from cod8a.models.models import (
+    FileStructure, ClassStructure, MethodStructure, 
+    FieldStructure, ParameterStructure, ProjectStructure, UsingDirective,
+    Relationship
+)
+from dataclasses import asdict
+
+class PythonParser:
+    def __init__(self):
+        self._id_counter = 0
+
+    def _next_id(self):
+        self._id_counter += 1
+        return self._id_counter
+
+    def parse_file(self, file_path: str) -> FileStructure:
+        with open(file_path, "r", encoding="utf-8") as f:
+            tree = ast.parse(f.read())
+
+        file_name = os.path.basename(file_path)
+        
+        file_struct = FileStructure(id=self._next_id(), name=file_name)
+
+        for node in tree.body:
+            if isinstance(node, (ast.Import, ast.ImportFrom)):
+                file_struct.using_directives.extend(self._parse_import(node))
+            elif isinstance(node, ast.ClassDef):
+                file_struct.classes.append(self._parse_class(node))
+        
+        return file_struct
+
+    def _parse_import(self, node) -> List[UsingDirective]:
+        directives = []
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                directives.append(UsingDirective(id=self._next_id(), name=alias.name))
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module or ""
+            for alias in node.names:
+                directives.append(UsingDirective(id=self._next_id(), name=f"{module}.{alias.name}"))
+        return directives
+
+    def _parse_class(self, node: ast.ClassDef) -> ClassStructure:
+        methods = []
+        fields = []
+        relationships = []
+        summary = ast.get_docstring(node) or ""
+
+        for base in node.bases:
+            if isinstance(base, ast.Subscript):
+                base_name = ast.unparse(base.value)
+            else:
+                base_name = ast.unparse(base)
+            
+            # PEP 544 protocols, standard ABCs, or conventional I-prefixed interfaces
+            is_interface = base_name in ("Protocol", "typing.Protocol", "ABC") or (len(base_name) > 1 and base_name[0] == 'I' and base_name[1].isupper())
+            rel_type = "Interface" if is_interface else "Class"
+            
+            relationships.append(Relationship(
+                id=self._next_id(),
+                type=rel_type,
+                parent_name=base_name
+            ))
+
+        for item in node.body:
+            if isinstance(item, ast.FunctionDef):
+                methods.append(self._parse_method(item))
+            elif isinstance(item, ast.Assign):
+                # Basic field extraction from class-level assignments
+                for target in item.targets:
+                    if isinstance(target, ast.Name):
+                        fields.append(FieldStructure(
+                            id=self._next_id(),
+                            name=target.id,
+                            modifier="private" if target.id.startswith("_") else "public",
+                            type="", # Type inference is complex, leaving empty for now
+                            summary=""
+                        ))
+            elif isinstance(item, ast.AnnAssign):
+                if isinstance(item.target, ast.Name):
+                    fields.append(FieldStructure(
+                        id=self._next_id(),
+                        name=item.target.id,
+                        modifier="private" if item.target.id.startswith("_") else "public",
+                        type=ast.unparse(item.annotation),
+                        summary=""
+                    ))
+
+        return ClassStructure(
+            id=self._next_id(),
+            name=node.name,
+            methods=methods,
+            fields=fields,
+            type="class",
+            associated_item=relationships,
+            summary=summary
+        )
+
+    def _parse_method(self, node: ast.FunctionDef) -> MethodStructure:
+        summary = ast.get_docstring(node) or ""
+        parameters = []
+        
+        for arg in node.args.args:
+            arg_type = ast.unparse(arg.annotation) if arg.annotation else ""
+            parameters.append(ParameterStructure(
+                name=arg.arg,
+                modifier="",
+                type=arg_type,
+                summary=""
+            ))
+
+        return MethodStructure(
+            id=self._next_id(),
+            name=node.name,
+            modifier="private" if node.name.startswith("_") else "public",
+            return_type=ast.unparse(node.returns) if node.returns else "",
+            parameters=parameters,
+            summary=summary
+        )
+
+    def parse_project(self, project_path: str) -> List[FileStructure]:
+        files = []
+        for root, _, filenames in os.walk(project_path):
+            for filename in filenames:
+                if filename.endswith(".py"):
+                    files.append(self.parse_file(os.path.join(root, filename)))
+        return files
+    
+    def parse(self, path: str) -> Union[FileStructure | ProjectStructure | List[FileStructure]]:
+        isFile = os.path.isfile(path)
+        if isFile:
+            return self.parse_file(path)
+        else:
+            return self.parse_project(path)

cod8a-0.1.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: cod8a
+Version: 0.1.0
+Summary: cod8a is a code documentation and visualization tool for Python and .NET projects
+License-Expression: MIT
+License-File: LICENSE
+Keywords: visualization,uml,docs,flowchart,class,sequence,diagram
+Author: Akumbom
+Author-email: akumbom5ma@gmail.com
+Maintainer: Marietta Akumbom
+Requires-Python: >=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: click (>=8.3.3,<9.0.0)
+Requires-Dist: pydantic (>=2.13.3,<3.0.0)
+Description-Content-Type: text/markdown
+
+# cod8a
+
+cod8a pronounced codetta, is a code documentation and visualization tool for **Python** and **.NET** projects.
+
+## Installation
+
+### Prerequisites
+
+- **[Python 3.9+](https://www.python.org/downloads/)**
+- **[.NET 10.0 Runtime or SDK](https://dotnet.microsoft.com/download/dotnet/10.0)** (Required **only** for C#/.NET analysis)
+
+### From PyPI (Recommended for Users)
+
+Once published, you can install `cod8a` directly using pip:
+
+```bash
+pip install cod8a
+```
+
+## Development & Contribution
+
+If you want to contribute to the project or run it from source:
+
+### Setup
+
+1. **Fork** the repository on GitHub.
+2. **Clone** your fork:
+
+```bash
+git clone https://github.com/yourusername/cod8a.git
+cd cod8a
+```
+
+### Development Options
+
+#### 1. Local Setup
+3. **Install** Python dependencies using **[Poetry](https://python-poetry.org/docs/#installation)**:
+
+```bash
+poetry install
+```
+
+4. **Optional**: Ensure .NET 10.0 is installed (if documenting C#)
+
+```bash
+dotnet --version
+```
+
+#### 2. VS Code Dev Container (Recommended)
+If you use VS Code, you can skip the local setup by using the provided **Dev Container**. It comes pre-configured with Python 3.13, .NET 10.0, and Poetry.
+- Simply open the project in VS Code and click **"Reopen in Container"** when prompted.
+
+#### 3. Docker
+You can also run `cod8a` as a standalone container without installing any dependencies locally:
+
+```bash
+# Build the image
+docker build -t cod8a .
+
+# Run the tool
+docker run -v $(pwd):/app/data cod8a uml -p /app/data/src
+```
+
+## Usage
+
+The tool uses a CLI interface to analyze code and generate visualizations.
+
+### UML Diagrams
+
+Generate Mermaid-compatible diagrams (Class, Sequence, Flowchart):
+
+```bash
+# General syntax
+cod8a uml -p <path_to_source> -d <diagram_type>
+
+# Generate a class diagram (default)
+cod8a uml -p src/my_project
+
+# Generate a sequence diagram
+cod8a uml -p src/my_file.py -d sequence
+
+# Generate a flowchart
+cod8a uml -p src/my_logic -d flow
+```
+
+#### Diagram Type Options:
+- **Class:** `class`, `c`
+- **Sequence:** `sequence`, `seq`, `s`
+- **Flowchart:** `flowchart`, `flow`, `f`
+
+### CLI Options
+
+- `-p, --path`: Path to the file or directory to analyze.
+- `-d, --diagram`: Type of diagram to generate (default: `class`).
+- `-o, --output`: Output file path (saves as `.mmd`).
+
+### Documentation (In development)
+
+*Note: This feature is currently in development.*
+
+Generate Markdown documentation from code structure:
+
+```bash
+# Not yet implemented
+cod8a doc -p path/to/source
+```
+
+## Features
+
+- **Mermaid Integration:** Generates high-quality Mermaid.js diagrams for visualization.
+  - **Supported Diagrams:** Class, Sequence, and Flowchart diagrams.
+- **C# Support:** Uses a Roslyn-based analyzer targeting **.NET 10.0** to extract deep structural information.
+- **Python Support:** Uses AST-based parsing for Python files.
+- **Markdown Documentation (TODO):** Detailed markdown generation for code documentation is currently in development.
+
+

cod8a-0.1.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+cod8a/__init__.py,sha256=2G4dr62W9xvYmUDbiAB9Y3aMAHEioMOfgJckiD94pQs,54
+cod8a/cli.py,sha256=0HmL65qdaQhwAiiutSIo8USgs6nvGgJLy17Wu44OD5w,3566
+cod8a/cod8a.py,sha256=gsTYm5tYUf8PXKSWHeQ0VhXYnLSITvkVMgqWLstXdZA,63
+cod8a/dotnet/CodeAnalysis/CodeAnalyzer.csproj,sha256=sVG2GYimAmjczJlgbruBqk9zTe5xcY2rj8LR0NuvT3E,368
+cod8a/dotnet/CodeAnalysis/CodeAnalyzer.csproj.lscache,sha256=rCYzc0WoWAA78d4tXG8-1ocyE4TOaOCJzb-xH2uwd1E,8581
+cod8a/dotnet/CodeAnalysis/models/FileStructure.cs,sha256=uZExZpv7gGXbgd2oSG8y3O_O_XY4ZQaZwLTlugczrl8,4862
+cod8a/dotnet/CodeAnalysis/models/ProjectStructure.cs,sha256=sScQ0FVu9b4cSPyer6nMMnqG5X7jbejSK1x8adQ6PCs,715
+cod8a/dotnet/CodeAnalysis/models/SolutionStructure.cs,sha256=Zlnm9fgpeqiXR0aG71W5UgP41rGip2NvHTuWgxD6NQw,789
+cod8a/dotnet/CodeAnalysis/Parsers/BaseParser.cs,sha256=R8AYxrApeB4_MVNBdLT_XfHQMpBV7u5arQkFMvD8824,446
+cod8a/dotnet/CodeAnalysis/Parsers/FileParser.cs,sha256=rTwz2qZjADEfQWnMonLjjH49Jx9X32F1HPB8eOuVchw,6884
+cod8a/dotnet/CodeAnalysis/Parsers/ProjectParser.cs,sha256=jn80iSgfxK329X1jIzw_vbMb-qbWynPnxVf1pHU3_FM,1040
+cod8a/dotnet/CodeAnalysis/Parsers/SolutionParser.cs,sha256=nPuCS-NjOwCckmlscs4AYN8eK16PYrKb99qdYoO5HEI,411
+cod8a/dotnet/CodeAnalysis/Program.cs,sha256=yf85xUT_bRvzXndjVMG6hV8TmD4k-0lO1KToZezDHNY,2052
+cod8a/dotnet/Test/CodeAnalyzerTest.csproj,sha256=lyoChgy51SvkE7RXn-Hr5l-mdqxHtoS42KpZfwivvtA,739
+cod8a/dotnet/Test/Mermaid/ClassDiagramTest.cs,sha256=U8gCKh7MOJP2ZONQxFtroPzwKuMGWCjjbwuK8BI764I,2242
+cod8a/enums/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cod8a/enums/diagram_type.py,sha256=b5YQJNbHoGVsR9bKVneSWuo90pbS84h3bfMZGgnbLtk,240
+cod8a/generators/mermaid/class_diagram.py,sha256=n7R14LkpYguAc0OUreTuCDi4hQ-E9zOkK9LggplcyK4,6518
+cod8a/generators/mermaid/flowchart_diagram.py,sha256=PM59a1_Enx73SIfILIzeUl1VqOqGpjV8S6_u6ecjJmo,2037
+cod8a/generators/mermaid/sequence_diagram.py,sha256=OZIdj8kPmNhup1rtp3hdFfT6MsHBsFaVDE8NS4vHrC0,3469
+cod8a/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cod8a/helpers/cli_helper.py,sha256=aBqHOEUms6EunAvUTT4u_6811VpxlFjZy8dhet1Ebu0,3316
+cod8a/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cod8a/models/models.py,sha256=nZXTTf4xEvWahOVSM1Bm8nfk1-QzVC_xHAU4GBX74GE,1135
+cod8a/parsers/dotnet_parser.py,sha256=di-3lyccQIuRyg4HgW2YMI0_wPIBJYJU3fymDIatX24,4226
+cod8a/parsers/python_parser.py,sha256=z2eRRgg6ajbZEJfGpWLI_Kc4-QNriils-75xqNFEKcw,5366
+cod8a-0.1.0.dist-info/entry_points.txt,sha256=6p5la6hORzIXOUyNIgvEOrpd_WKAtzM2K6f9c1_KsVQ,65
+cod8a-0.1.0.dist-info/licenses/LICENSE,sha256=V7c7VSiN0ITBMW_RLOzN65ku49BtA8tNYsbyS2427Vg,1099
+cod8a-0.1.0.dist-info/METADATA,sha256=IES0VV_q6R8EhVeLRBIoVw-rtLbFe83uLftJnwF8vgc,3588
+cod8a-0.1.0.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+cod8a-0.1.0.dist-info/RECORD,,

cod8a-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.1
+Root-Is-Purelib: true
+Tag: py3-none-any

cod8a-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+cde8a=cod8a.cli:doc_main
+cod8a=cod8a.cli:main
+

cod8a-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marietta Ngwe Akumbom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.