EasyDocPy 1.2.0__tar.gz

easydocpy-1.2.0/EasyDocPy.egg-info/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: EasyDocPy
+Version: 1.2.0
+Summary: python documentation generator
+Author: epsilonkn
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/epsilonkn/EasyDoc
+Project-URL: Issues, https://github.com/epsilonkn/EasyDoc/issues
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Doc
+
+**Welcome to the page of the EasyDoc project**
+
+The idea of that package is to create a technical documentation of a python source file, from the docstrings and the commentary in the source code : yes, the more you comment your code, the more the module will scrap.
+
+For more information, read the wiki : https://github.com/epsilonkn/EasyDoc/wiki
+
+## To use it : 
+
+### To comment your code :
+
+#### **declarations :**
+
+Is accepted for classes
+
+    class obj(*parents):
+
+or 
+
+    class obj:
+
+Is accepted for functions :
+
+    def foo(arg, agr2 = 10, arg 3 : str = "poo", *args, **kwargs) -> None :
+
+or 
+
+    def foo(arg, 
+            agr2 = 10, 
+            arg 3 : str = "poo", 
+            *args, 
+            **kwargs) -> None :
+
+Note : the tabs before the "def" are obviously accepted, but the module will assume a function with tabs before is a method of a class.
+
+#### **docstrings :**
+
+The docstrings MUST be defined by 3 double quotes at the beginning and same at the end, otherwise it won't work.
+\
+You can place docstrings below your classes, methods and functions to detail them, they can be juste below the declaration, or some lines below. There can be 1 or multiple docstrings, but they will all get concatenated into one.
+
+Examples : 
+
+    class foo:
+        """
+        a detail
+        """
+
+    class foo:
+        """a detail"""
+
+    def foo(*args):
+        """
+        detail
+
+        args:
+            args : detail
+        """
+    
+    def foo(*args):
+        """detail"""
+
+
+#### **custom comment lines :**
+
+To enhance your documentation, there are a few custom comments you can do :
+
+**#/actual_version**
+\
+Define the version of the file
+
+    Use :
+    #/actual_version : V.1.9.25
+
+**#/author :**
+\
+Define the author the file
+
+    Use :
+    #/author : epsilonkn
+
+**#/creation_date :**
+\
+Date of creation of the file
+
+    Use :
+    #/creation_date : 01/01/1900
+
+**#/last_release_date :**
+\
+Last date of release of the file
+
+    Use :
+    #/last_release_date : 02/01/1900
+
+**#/TODO :**
+\
+List all the todo in the file
+
+    Use :
+    #/TODO Find time to write the doc
+    #/TODO Write the doc when dev is done
+    #/TODO Write the doc of this file
+
+**#/planned :**
+\
+List all the planned future versions
+
+    Use :
+    #/planned V2 : rewrite the code for better scalability
+    #/planned V2.1 : patch the errors of the new code
+    #/planned V2.2 : ......
+
+**#/file_intro :**
+\
+Marks the begin of the file intro. the file intro follows the same rules as the function's docstrings.
+
+    Use :
+    #/file_intro
+    """
+    this file is meant to provide the result of the operation 2+2
+    it takes as a paramter....
+    """
+
+**#/const :**
+\
+Explains a constant in the code. for now, all the constants are written at the begining of the doc no matter if they're class's constants or file's constants.
+
+    Use :
+    #/const CONST defines the gravitation force for calculus purposes
+    CONST = 10
+    #/const DEFAULT defines the default values for the empty strings
+    DEFAULT = "VOID"
+
+
+#### Generate the documentation :
+
+### In a terminal :
+
+Here is the only way implemented to generate a documentation in command line :
+
+    easydoc file "/your/path/to/file.py"
+
+Note 1 : your terminal must be in the directory where you want to see the documentation generated.
+
+Note 2 : you can pass the path without double quotes, however it is better to keep them if your path got spaces in it.
+
+### In a python program :
+
+Disclaimer : Running the module in a program by calling directly the classes can be possible, but this might also opens a pandora box of bugs.
+
+The reason you would need to run the module manually in a python file is to get a better control over the process.
+Unfortunately, in the actual state of the module, the control over the module is still very little, this will be improved in the next updates.
+
+If you still wish to do it in a program rather than in command line, here is the base :
+
+    From easydoc import Parser, MarkdownGenerator
+
+    parser = Parser(path = "/path/to/file.py", automatic = False)
+    parse_list = parser.get_parse()
+    file_header = parser.get_intro()
+
+    MarkdownGenerator(parse_list, file_header, doc_file_name)
+
+
+
+## Next updates :
+
+|Version | Improvement|
+|-|-|
+|V 1.2.0 | adding custom comment line to add info to the documentation|
+|V 1.3.0| better control over the process when done in a program |
+|V 1.4.0| adding doc generation for an entire directory |
+|V 1.5.0| adding user configuration |
+|......||
+
+## API :
+
+For now there is no released API entry points in the module, you'll have to wait for the V1.3 and V1.5 for these parts

easydocpy-1.2.0/EasyDocPy.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+EasyDocPy.egg-info/PKG-INFO
+EasyDocPy.egg-info/SOURCES.txt
+EasyDocPy.egg-info/dependency_links.txt
+EasyDocPy.egg-info/entry_points.txt
+EasyDocPy.egg-info/top_level.txt
+easydoc/__init__.py
+easydoc/__main__.py
+easydoc/analyser.py
+easydoc/generator.py
+easydoc/objects.py
+easydoc/config/custom_comment_lines.json
+easydoc/templates/template.md

easydocpy-1.2.0/EasyDocPy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

easydocpy-1.2.0/EasyDocPy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+easydoc = easydoc.cli:main

easydocpy-1.2.0/EasyDocPy.egg-info/top_level.txt

@@ -0,0 +1 @@
+easydoc

easydocpy-1.2.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 Ywan Maxime GERARD
+
+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.

easydocpy-1.2.0/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: EasyDocPy
+Version: 1.2.0
+Summary: python documentation generator
+Author: epsilonkn
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/epsilonkn/EasyDoc
+Project-URL: Issues, https://github.com/epsilonkn/EasyDoc/issues
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Doc
+
+**Welcome to the page of the EasyDoc project**
+
+The idea of that package is to create a technical documentation of a python source file, from the docstrings and the commentary in the source code : yes, the more you comment your code, the more the module will scrap.
+
+For more information, read the wiki : https://github.com/epsilonkn/EasyDoc/wiki
+
+## To use it : 
+
+### To comment your code :
+
+#### **declarations :**
+
+Is accepted for classes
+
+    class obj(*parents):
+
+or 
+
+    class obj:
+
+Is accepted for functions :
+
+    def foo(arg, agr2 = 10, arg 3 : str = "poo", *args, **kwargs) -> None :
+
+or 
+
+    def foo(arg, 
+            agr2 = 10, 
+            arg 3 : str = "poo", 
+            *args, 
+            **kwargs) -> None :
+
+Note : the tabs before the "def" are obviously accepted, but the module will assume a function with tabs before is a method of a class.
+
+#### **docstrings :**
+
+The docstrings MUST be defined by 3 double quotes at the beginning and same at the end, otherwise it won't work.
+\
+You can place docstrings below your classes, methods and functions to detail them, they can be juste below the declaration, or some lines below. There can be 1 or multiple docstrings, but they will all get concatenated into one.
+
+Examples : 
+
+    class foo:
+        """
+        a detail
+        """
+
+    class foo:
+        """a detail"""
+
+    def foo(*args):
+        """
+        detail
+
+        args:
+            args : detail
+        """
+    
+    def foo(*args):
+        """detail"""
+
+
+#### **custom comment lines :**
+
+To enhance your documentation, there are a few custom comments you can do :
+
+**#/actual_version**
+\
+Define the version of the file
+
+    Use :
+    #/actual_version : V.1.9.25
+
+**#/author :**
+\
+Define the author the file
+
+    Use :
+    #/author : epsilonkn
+
+**#/creation_date :**
+\
+Date of creation of the file
+
+    Use :
+    #/creation_date : 01/01/1900
+
+**#/last_release_date :**
+\
+Last date of release of the file
+
+    Use :
+    #/last_release_date : 02/01/1900
+
+**#/TODO :**
+\
+List all the todo in the file
+
+    Use :
+    #/TODO Find time to write the doc
+    #/TODO Write the doc when dev is done
+    #/TODO Write the doc of this file
+
+**#/planned :**
+\
+List all the planned future versions
+
+    Use :
+    #/planned V2 : rewrite the code for better scalability
+    #/planned V2.1 : patch the errors of the new code
+    #/planned V2.2 : ......
+
+**#/file_intro :**
+\
+Marks the begin of the file intro. the file intro follows the same rules as the function's docstrings.
+
+    Use :
+    #/file_intro
+    """
+    this file is meant to provide the result of the operation 2+2
+    it takes as a paramter....
+    """
+
+**#/const :**
+\
+Explains a constant in the code. for now, all the constants are written at the begining of the doc no matter if they're class's constants or file's constants.
+
+    Use :
+    #/const CONST defines the gravitation force for calculus purposes
+    CONST = 10
+    #/const DEFAULT defines the default values for the empty strings
+    DEFAULT = "VOID"
+
+
+#### Generate the documentation :
+
+### In a terminal :
+
+Here is the only way implemented to generate a documentation in command line :
+
+    easydoc file "/your/path/to/file.py"
+
+Note 1 : your terminal must be in the directory where you want to see the documentation generated.
+
+Note 2 : you can pass the path without double quotes, however it is better to keep them if your path got spaces in it.
+
+### In a python program :
+
+Disclaimer : Running the module in a program by calling directly the classes can be possible, but this might also opens a pandora box of bugs.
+
+The reason you would need to run the module manually in a python file is to get a better control over the process.
+Unfortunately, in the actual state of the module, the control over the module is still very little, this will be improved in the next updates.
+
+If you still wish to do it in a program rather than in command line, here is the base :
+
+    From easydoc import Parser, MarkdownGenerator
+
+    parser = Parser(path = "/path/to/file.py", automatic = False)
+    parse_list = parser.get_parse()
+    file_header = parser.get_intro()
+
+    MarkdownGenerator(parse_list, file_header, doc_file_name)
+
+
+
+## Next updates :
+
+|Version | Improvement|
+|-|-|
+|V 1.2.0 | adding custom comment line to add info to the documentation|
+|V 1.3.0| better control over the process when done in a program |
+|V 1.4.0| adding doc generation for an entire directory |
+|V 1.5.0| adding user configuration |
+|......||
+
+## API :
+
+For now there is no released API entry points in the module, you'll have to wait for the V1.3 and V1.5 for these parts

easydocpy-1.2.0/README.md

@@ -0,0 +1,180 @@
+# Doc
+
+**Welcome to the page of the EasyDoc project**
+
+The idea of that package is to create a technical documentation of a python source file, from the docstrings and the commentary in the source code : yes, the more you comment your code, the more the module will scrap.
+
+For more information, read the wiki : https://github.com/epsilonkn/EasyDoc/wiki
+
+## To use it : 
+
+### To comment your code :
+
+#### **declarations :**
+
+Is accepted for classes
+
+    class obj(*parents):
+
+or 
+
+    class obj:
+
+Is accepted for functions :
+
+    def foo(arg, agr2 = 10, arg 3 : str = "poo", *args, **kwargs) -> None :
+
+or 
+
+    def foo(arg, 
+            agr2 = 10, 
+            arg 3 : str = "poo", 
+            *args, 
+            **kwargs) -> None :
+
+Note : the tabs before the "def" are obviously accepted, but the module will assume a function with tabs before is a method of a class.
+
+#### **docstrings :**
+
+The docstrings MUST be defined by 3 double quotes at the beginning and same at the end, otherwise it won't work.
+\
+You can place docstrings below your classes, methods and functions to detail them, they can be juste below the declaration, or some lines below. There can be 1 or multiple docstrings, but they will all get concatenated into one.
+
+Examples : 
+
+    class foo:
+        """
+        a detail
+        """
+
+    class foo:
+        """a detail"""
+
+    def foo(*args):
+        """
+        detail
+
+        args:
+            args : detail
+        """
+    
+    def foo(*args):
+        """detail"""
+
+
+#### **custom comment lines :**
+
+To enhance your documentation, there are a few custom comments you can do :
+
+**#/actual_version**
+\
+Define the version of the file
+
+    Use :
+    #/actual_version : V.1.9.25
+
+**#/author :**
+\
+Define the author the file
+
+    Use :
+    #/author : epsilonkn
+
+**#/creation_date :**
+\
+Date of creation of the file
+
+    Use :
+    #/creation_date : 01/01/1900
+
+**#/last_release_date :**
+\
+Last date of release of the file
+
+    Use :
+    #/last_release_date : 02/01/1900
+
+**#/TODO :**
+\
+List all the todo in the file
+
+    Use :
+    #/TODO Find time to write the doc
+    #/TODO Write the doc when dev is done
+    #/TODO Write the doc of this file
+
+**#/planned :**
+\
+List all the planned future versions
+
+    Use :
+    #/planned V2 : rewrite the code for better scalability
+    #/planned V2.1 : patch the errors of the new code
+    #/planned V2.2 : ......
+
+**#/file_intro :**
+\
+Marks the begin of the file intro. the file intro follows the same rules as the function's docstrings.
+
+    Use :
+    #/file_intro
+    """
+    this file is meant to provide the result of the operation 2+2
+    it takes as a paramter....
+    """
+
+**#/const :**
+\
+Explains a constant in the code. for now, all the constants are written at the begining of the doc no matter if they're class's constants or file's constants.
+
+    Use :
+    #/const CONST defines the gravitation force for calculus purposes
+    CONST = 10
+    #/const DEFAULT defines the default values for the empty strings
+    DEFAULT = "VOID"
+
+
+#### Generate the documentation :
+
+### In a terminal :
+
+Here is the only way implemented to generate a documentation in command line :
+
+    easydoc file "/your/path/to/file.py"
+
+Note 1 : your terminal must be in the directory where you want to see the documentation generated.
+
+Note 2 : you can pass the path without double quotes, however it is better to keep them if your path got spaces in it.
+
+### In a python program :
+
+Disclaimer : Running the module in a program by calling directly the classes can be possible, but this might also opens a pandora box of bugs.
+
+The reason you would need to run the module manually in a python file is to get a better control over the process.
+Unfortunately, in the actual state of the module, the control over the module is still very little, this will be improved in the next updates.
+
+If you still wish to do it in a program rather than in command line, here is the base :
+
+    From easydoc import Parser, MarkdownGenerator
+
+    parser = Parser(path = "/path/to/file.py", automatic = False)
+    parse_list = parser.get_parse()
+    file_header = parser.get_intro()
+
+    MarkdownGenerator(parse_list, file_header, doc_file_name)
+
+
+
+## Next updates :
+
+|Version | Improvement|
+|-|-|
+|V 1.2.0 | adding custom comment line to add info to the documentation|
+|V 1.3.0| better control over the process when done in a program |
+|V 1.4.0| adding doc generation for an entire directory |
+|V 1.5.0| adding user configuration |
+|......||
+
+## API :
+
+For now there is no released API entry points in the module, you'll have to wait for the V1.3 and V1.5 for these parts

easydocpy-1.2.0/easydoc/__init__.py

@@ -0,0 +1,11 @@
+from .objects import *
+from .generator import MarkdownGenerator
+from .analyser import Parser
+
+#/TODO add dir treatment
+#/TODO add API entry points
+
+__all__ = [
+    "MarkdownGenerator",
+    "Parser"
+        ]

easydocpy-1.2.0/easydoc/__main__.py

@@ -0,0 +1,29 @@
+import sys
+from .analyser import Parser
+import pathlib
+
+from importlib.metadata import version
+
+if "--version" == sys.argv[1]:
+    print("PyEasyDoc", version("PyEasyDoc"))
+    exit(0)
+
+types = ["file", "dir"]
+
+if sys.argv[1] not in types : 
+    raise ValueError(f"The parameter {sys.argv[1]} is invalid\neasydoc accepts only \"file\" and \"dir\"")
+
+path = pathlib.Path(sys.argv[2])
+
+if not path.exists() : 
+    raise ValueError(f"The path {sys.argv[2]} is doesn't exists")
+
+match sys.argv[1] :
+
+    case "file":
+        if path.suffix != ".py" : 
+            raise ValueError(f"The path {sys.argv[2]} doesn't point to a python file")
+        Parser(path)
+    case "group":
+        if path.suffix != ".py" : 
+            raise NotImplementedError("the directory documentation mode hasn't been developped yet.")

easydocpy-1.2.0/easydoc/analyser.py

@@ -0,0 +1,359 @@
+#/file_intro
+"""
+Module d'analyse d'un fichier source python
+contient les classes de données ainsi que la classe Analyse qui se charge du parsing
+
+Raises:
+    IndexError: raise IndexError si la classe Analyse détecte une parenthèse non fermée 
+    empêchant la détection de la fin d'une fonction
+"""
+
+
+#/actual_version : 1.2.0
+#/last_release_date : 20/02/2026                         
+#/author : Ywan GERARD
+
+
+from importlib.resources import files
+import json
+from pathlib import Path
+import re
+import sys
+from .objects import *
+from .generator import MarkdownGenerator
+
+
+
+class Parser:
+    """
+    Cette classe parcours le fichier source, identifie les classes et fonctions
+    et identifie les docstrings présents pour chaque classe et fonction
+    """
+
+    def __init__(self, path, automatic : bool = True):
+        """
+        initialise les attributs de la classe :
+        -fpath contient le chemin vers le fichier source
+        -fname contient le nom du fichier source
+        -parse est une liste contenant les classes et fonctions indépendantes scrappées
+        -intro contient le docstring en en-tête du fichier source
+
+        Args:
+            path (str): chemin vers le fichier source.
+            automatic (bool): chemin vers le fichier source.
+        """
+        self.auto = automatic
+        self.fpath = Path(path)
+        self.fname = self.fpath.stem
+        self.parse : list[Parsed_class, Parsed_function] = []
+        self.customs : dict = self.open_custom_config()
+        self.file_data : list[Custom_comment] = []
+        self.pointer = 0
+        self.parse_source()
+        if self.auto :
+            MarkdownGenerator(self.parse, self.file_data, self.fname)
+
+        
+
+    def get_parse(self): 
+         return self.parse
+
+
+    def parse_source(self):
+        """
+        parcours le code à la recherche d'une déclaration de classe, de fonction
+        et recherche un docstring rattaché à aucune classe ni fonction
+        ce docstring indépendant est interprété comme une explication du fichier source
+        """
+        source : list[str]= self.get_source()
+        print("classes and functions found :")
+        while  self.pointer < len(source):
+            if self.is_class(source[ self.pointer]): 
+                print(source[ self.pointer])
+                self.pointer += self.class_parser(source[ self.pointer:])
+
+            elif self.is_function(source[ self.pointer:]): 
+                print(source[ self.pointer])
+                self.pointer += self.function_parser(source[ self.pointer:])
+
+            elif custom:=self.is_custom(source[ self.pointer]) :
+                self.pointer += self.parse_custom(custom, source[self.pointer:])
+
+            else :
+                self.pointer += 1
+
+    
+    def is_custom(self, line : str) -> bool:
+        for custom in self.customs:
+            if custom in line :
+                return custom
+        return False
+    
+
+    def parse_custom(self, custom : str, lines : list[str]):
+        pointer = 0
+        content = ""
+        match custom :
+            case "#/file_intro" :
+                pointer += 1
+                if self.is_oneline_docstring(lines[pointer]) : 
+
+                    content = self.format_string(lines[pointer].replace('"""', ""))
+                    pointer +=1
+
+                elif self.is_docstring(lines[pointer]) : 
+                    content = self.format_string(lines[pointer].replace('"""', ""))
+                    pointer +=1
+                    while not self.is_docstring(lines[pointer]):
+                        content += self.format_string(lines[pointer].replace('"""', "")).replace("\t", "")
+                        pointer +=1
+                    pointer +=1
+                    
+            case _ :
+                content = lines[pointer].replace(custom, "").replace("\n", "")
+                pointer += 1
+        obj = Custom_comment(self.customs[custom]["type"], self.customs[custom]["ref"], self.customs[custom]["is_list"], content )
+        self.file_data.append(obj)
+        return pointer
+
+
+    def is_class(self, line: str) -> bool:
+        """
+        Vérifie si une ligne est une déclaration de classe
+
+        Args:
+            line (str): ligne à vérifier
+
+        Returns:
+            bool: retourne True si la ligne est une déclaration de classe, False sinon
+        """
+        return bool(re.search(r"^class\s.*:", line))
+    
+
+    def is_function(self, lines : list[str], in_class = False) -> bool:
+        """
+        Vérifie si la ligne du pointer est une fonction, ou le début d'une fonction dont l'en-tête est sur plusieurs lignes :
+        ex : 
+
+        def funct( param1 = "foo", param2 = ("poo", 1)) -> None:
+
+        ou
+
+        def funct(
+            param1 = "foo",
+            param2 = ("poo", 1)
+        ) -> None:
+
+        Args:
+            line (list[str]): lignes à vérifier
+            in_class (bool, optional): indique si il s'agit d'une méthode ou d'une fonction. Defaults to False.
+
+        Returns:
+            bool: retourne True si il s'agit d'une déclaration de fonction, False sinon
+        """
+        if not in_class : pat = r"^def\s+[a-zA-Z_]\w*\s*\(.*"
+        else : pat = r"^\s+def\s+[a-zA-Z_]\w*\s*\(.*"
+        pointer = 0
+
+        if re.search(pat, lines[0]) :
+            opened = lines.count("(") - lines.count(")")
+            while opened != 0 and pointer < len(lines):
+                pointer += 1
+                opened += lines.count("(") - lines.count(")")
+            if opened == 0:
+                return True
+            if not opened and pointer >= len(lines):
+                raise IndexError(f"a parenthesis was opened but never closed on line \n {lines[0]}\nFailed to parse the module")
+        else :
+            return False
+
+
+    def get_function_declaration(self, lines : list[str]) -> tuple[str, int]:
+        """
+        Récupère la déclaration de la fonction et la retoure
+        ex : 
+
+        def funct( param1 = "foo", param2 = ("poo", 1)) -> None:
+
+        ou
+
+        def funct(
+            param1 = "foo",
+            param2 = ("poo", 1)
+        ) -> None:
+
+        Args:
+            line (list[str]): lignes où se trouvent la déclaration
+            in_class (bool, optional): indique si il s'agit d'une méthode ou d'une fonction. Defaults to False.
+
+        Returns:
+            str: retourne la déclaration de la fonction sous forme d'un string
+        """
+        decla = ""
+        pointer = 0
+
+        opened = lines[pointer].count("(") - lines[pointer].count(")")
+        decla = lines[0]
+        while opened != 0 and pointer < len(lines):
+            pointer += 1
+            opened += lines[pointer].count("(") - lines[pointer].count(")")
+            decla += lines[pointer]
+        if opened == 0:
+            return self.format_string(decla), pointer + 1
+        if not opened and pointer >= len(lines):
+            raise IndexError(f"a parenthesis was opened but never closed on line \n {lines[0]}\nFailed to parse the module")
+
+
+    def class_parser(self, sub_source : list[str]) -> int: 
+        """
+        isole la déclaration d'une classe, son docstring éventuel,
+        puis parcours le code de la classe à la recherche de méthodes
+
+        Args:
+            sub_source (list[str]): code source commençant à partir de la déclaration de la classe
+
+        Returns:
+            int: retourne la taille de la classe en nombre de ligne, évite que le parseur principal repasse sur du code déjà parsé
+        """
+        obj = Parsed_class(sub_source[0], "")
+        pointer = 1
+        docstring = ""
+        while pointer < len(sub_source) and not self.is_class(sub_source[pointer]) and not self.is_function(sub_source[pointer:]) :
+
+            if self.is_oneline_docstring(sub_source[pointer]) : 
+                docstring = self.format_string(sub_source[pointer].replace('"""', ""))
+                pointer +=1
+
+            elif self.is_docstring(sub_source[pointer]) : 
+                docstring += self.format_string(sub_source[pointer].replace('"""', ""))
+                pointer +=1
+                while not self.is_docstring(sub_source[pointer]):
+                    docstring += self.format_string(sub_source[pointer].replace('"""', ""))
+                    pointer +=1
+                pointer +=1
+
+            elif self.is_function(sub_source[pointer:], in_class=True) : 
+                print(sub_source[pointer])
+                pointer += self.function_parser(sub_source[pointer:], obj)
+
+            else :
+                pointer += 1
+        obj.docstring = docstring
+        self.parse.append(obj)
+        return pointer
+
+
+    def function_parser(self, sub_source : list[str], parent : Parsed_class = None) -> int:
+        """
+        isole la déclaration d'une fonction et récupère son docstring éventuel,
+
+        Args:
+            sub_source (list[str]): code source commençant à partir de la déclaration de la fonction
+            parent (Parsed_class, optional): si le paramètre est fourni, alors function_parser
+            considèrera que la fonction à scraper est une méthode appartenant à la classe "parent". Defaults to None.
+
+        Returns:
+            int: retourne la taille de la fonction en nombre de ligne, évite que le parseur principal repasse sur du code déjà parsé
+        """        
+        declaration, pointer = self.get_function_declaration(sub_source)
+        docstring = ""
+        while pointer < len(sub_source) \
+            and not self.is_function(sub_source[pointer:], in_class=True) \
+            and not self.is_class(sub_source[pointer]) \
+            and not self.is_function(sub_source[pointer:]) :
+                
+                if self.is_oneline_docstring(sub_source[pointer]) : 
+
+                    docstring = self.format_string(sub_source[pointer].replace('"""', ""))
+                    pointer +=1
+
+                elif self.is_docstring(sub_source[pointer]) : 
+                    docstring += self.format_string(sub_source[pointer].replace('"""', ""))
+                    pointer +=1
+                    while not self.is_docstring(sub_source[pointer]):
+                        docstring += self.format_string(sub_source[pointer].replace('"""', ""))
+                        pointer +=1
+                    pointer +=1
+                else :
+                    pointer += 1
+        obj = Parsed_function(declaration, docstring)    
+        if parent :
+            parent.add_method(obj)
+        else :
+            self.parse.append(obj)
+        return pointer
+    
+
+    def is_docstring(self, line: str) -> bool:
+        """
+        Vérifie si une ligne est le début d'un docstring sur plusieurs lignes
+
+        Args:
+            line (str): ligne à vérifier
+
+        Returns:
+            bool: retourne True si il s'agit du début d'un docstring, False sinon
+        """
+        return bool(re.search(r"(?<!')\"{3}", line))
+    
+
+    def is_oneline_docstring(self, line: str) -> bool:
+        """
+        Vérifie si une ligne est une doctring sur une seule ligne, par exemple :
+
+        '''doctring d'une fonction'''
+
+        Args:
+            line (str): ligne à vérifier
+
+        Returns:
+            bool: retourne True si il s'agit d'un docstring sur une ligne, False sinon
+        """
+        return line.count('"""') == 2
+
+
+    def format_string(self, string : str) -> str :
+        """
+        Formate le string passé en paramètre,
+        remplace les chaine de tabs supérieures à 3 par une double tab,
+        si aucune tab n'est présente dans la chaine, la fonction en ajoute une en début de chaine
+
+        Args:
+            string (str): string à traiter
+
+        Returns:
+            str: retourne la chaine traité selon l'algorithme défini plus haut
+        """
+        string = re.sub("\s{4}", "\t", string)
+        if "\t" in string :
+            nb_tab : str = "\t" * string.count("\t")
+
+            string = string.replace(nb_tab, "\t")
+        else :
+            string = "\t" + string
+        return string
+
+
+    def get_source(self) -> list[str]:
+        """
+        Ouvre et retourne le code source du fichier choisi
+
+        Returns:
+            list[str]: retourne une liste dont chaque élément est une ligne du fichier source à parser
+        """
+        with open(self.fpath, 'r', encoding='utf-8') as f:
+            return f.readlines()
+
+
+    @staticmethod
+    def open_custom_config() -> dict:
+        with open(files("easydoc.config").joinpath("custom_comment_lines.json"), 'r', encoding='utf-8') as f :
+            return json.load(f)
+    
+
+if __name__ == "__main__" :
+    if len(sys.argv) >= 2 :
+        path = sys.argv[1]
+        Parser(path)
+    else :
+        raise IndexError("Aucun fichier source fourni, arrêt du programme")

easydocpy-1.2.0/easydoc/config/custom_comment_lines.json

@@ -0,0 +1,10 @@
+{
+    "#/actual_version" : {"ref" : "%version%", "type" : "Version", "is_list" : false},
+    "#/author" : {"ref" : "%author%", "type" : "Author", "is_list" : false},
+    "#/creation_date" : {"ref" : "%creation_date%", "type" : "Creation_date", "is_list" : false},
+    "#/last_release_date" : {"ref" : "%last_release_date%", "type" : "Last_release_date", "is_list" : false},
+    "#/TODO" : {"ref" : "%TODO%", "type" : "TODO", "is_list" : true},
+    "#/planned" : {"ref" : "%roadmap%", "type" : "Roadmap", "is_list" : true},
+    "#/file_intro" : {"ref" : "%intro%", "type" : "Sum-up", "is_list" : false},
+    "#/const" : {"ref" : "%const%", "type" : "Constants", "is_list" : true}
+}

easydocpy-1.2.0/easydoc/generator.py

@@ -0,0 +1,155 @@
+#-----------------------------------------------------------------------------------------
+# Fichier : analyser.py
+# Version : 1.2
+# Dernier changement : 21/02/2026                         
+# dernier éditeur : Ywan GERARD
+# Créateur : Ywan GERARD
+#
+#-----------------------------------------------------------------------------------------
+
+import json
+import re
+
+from .objects import Parsed_class, Parsed_function, Custom_comment
+import os
+from importlib.resources import files
+
+
+class MarkdownGenerator:
+
+    def __init__(self, obj_list, custom_list : list[Custom_comment], fname):
+        body : str = self.open_pattern()
+        customs = self.open_custom_config()
+        custom_done = []
+        body = body.replace("%module_name%", fname)
+        for elt in custom_list :
+            if elt.type_ in custom_done:
+                continue
+            elif elt.is_list :
+                part = self.generate_custom_list(custom_list, elt.type_)
+                body = body.replace(elt.ref, part)
+                custom_done.append(elt.type_)
+            else :
+                body = body.replace(elt.ref, f"{self._custom_header_wrap(elt.type_.replace("_"," "))}{elt.content}\n\\")
+
+                custom_done.append(elt.type_)
+        
+        for elt in customs :
+            if customs[elt]["type"] not in custom_done :
+                print(customs[elt]["ref"])
+                body = body.replace(f"{customs[elt]["ref"]}\n", "")
+
+        for elt in obj_list :
+            if isinstance(elt, Parsed_class):
+                body += self.generate_class(elt)
+
+        for elt in obj_list :
+            if isinstance(elt, Parsed_function):
+                body += self.generate_function(elt)
+
+        body = re.sub(r"\\\n[^a-zA-Z]*\n", "\n", body)
+
+        self.create_file(fname, body)
+
+
+    # --------------- default wrapper functions ------------------
+
+
+    @staticmethod
+    def _class_wrap(name) : 
+        return f"\n### Classe {name} :\n---\n"
+    @staticmethod
+    def _method_wrap(name) : 
+        return f"\n#### **Methode {name} :**\n"
+    @staticmethod
+    def _function_wrap(name) : 
+        return f"\n### Fonction {name} :\n"
+    @staticmethod
+    def _main_name_wrap(name) : 
+        return f"\n### Fonction {name} :\n"
+    @staticmethod
+    def _custom_list_wrap(name) : 
+        return f"\n### {name} :\n"
+    @staticmethod
+    def _custom_header_wrap(name) : 
+        return f"**{name}**\n"
+    
+
+    # --------------- hook functions ------------------
+
+
+    @classmethod
+    def set_class_wrap(cls, wrapper) : 
+        cls._class_wrap = wrapper
+        return wrapper
+    
+    @classmethod
+    def set_method_wrap(cls, wrapper) : 
+        cls._method_wrap = wrapper
+        return wrapper
+    
+    @classmethod
+    def set_function_wrap(cls, wrapper) : 
+        cls._function_wrap = wrapper
+        return wrapper
+    
+    @classmethod
+    def set_main_name_wrap(cls, wrapper) : 
+        cls._main_name_wrap = wrapper
+        return wrapper
+
+
+    # --------------- files related functions ------------------
+
+
+    @staticmethod
+    def open_pattern():
+        return files("easydoc.templates").joinpath("template.md").read_text()
+    
+
+    @staticmethod
+    def open_custom_config() -> dict:
+        with open(files("easydoc.config").joinpath("custom_comment_lines.json"), 'r', encoding='utf-8') as f :
+            return json.load(f)
+    
+    
+    @staticmethod
+    def create_file(name, body):
+        with open(f"{os.getcwd()}/{name}_doc.md", 'w', encoding="utf-8") as f:
+            return f.write(body)
+        
+
+    # --------------- generation functions ------------------
+
+
+    def generate_custom_list(self, customs : list[Custom_comment], type_):
+        md = self._custom_list_wrap(type_)
+        elem_list = [cust for cust in customs if cust.type_ == type_]
+        for elem in elem_list:
+            md += elem.content + "\n\\\n"
+        return md
+    
+
+
+    def generate_class(self, classe : Parsed_class):
+        subbody = self._class_wrap(classe.name)
+        subbody += f"\nDéclaration :\n\n\t{classe.declaration}"
+        subbody += f"\nDescription :\n{classe.docstring}"
+        for func in classe.methods:
+            subbody += self.generate_function(func, True)
+
+        return subbody
+
+
+    def generate_function(self, func : Parsed_function, in_class : bool = False):
+        if in_class :
+            subbody = self._method_wrap(func.name)
+        else : 
+            subbody = self._function_wrap(func.name)
+
+        
+        subbody += f"\nDéclaration :\n\n{func.declaration}"
+        if func.docstring:
+            subbody += f"\nDescription :\n\n{func.docstring}"
+
+        return subbody

easydocpy-1.2.0/easydoc/objects.py

@@ -0,0 +1,44 @@
+import re
+
+class Parsed_function:
+
+    def __init__(self, declaration, docstring):
+        self.name : str = ""
+        self.declaration : str = ""
+        self.set_declaration(declaration)
+        self.docstring : str = docstring
+
+
+    def set_declaration(self, declaration):
+        self.declaration = declaration
+        self.name = re.search(r"^\s*(?:def|class)\s+([a-zA-Z_]\w*)", declaration).group(1)
+
+
+class Custom_comment:
+
+    def __init__(self, type_, ref, is_list, content):
+        self.type_ : str = type_
+        self.ref : str = ref
+        self.is_list : bool = is_list
+        self.content : str = content
+
+
+
+class Parsed_class:
+
+    def __init__(self, declaration, docstring):
+        self.name : str = ""
+        self.declaration : str = ""
+        self.set_declaration(declaration)
+        self.docstring : str = docstring
+        self.methods : list[Parsed_function] = []
+
+
+    def set_declaration(self, declaration):
+        self.declaration = declaration
+        self.name = re.search(r"^\s*(?:def|class)\s+([a-zA-Z_]\w*)", declaration).group(1)
+
+
+    def add_method(self, method : Parsed_function):
+        self.methods.append(method)
+

easydocpy-1.2.0/easydoc/templates/template.md

@@ -0,0 +1,20 @@
+# %module_name%
+
+## Introduction
+
+%version%
+%author%
+%creation_date%
+%last_release_date%
+
+%intro%
+
+%roadmap%
+
+%TODO%
+
+## Uses
+
+## Technical details
+
+%const%

easydocpy-1.2.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "EasyDocPy"
+version = "1.2.0"
+description = "python documentation generator"
+dependencies = []
+authors = [{ name="epsilonkn" }]
+requires-python = ">=3.12"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project.scripts]
+easydoc = "easydoc.cli:main"
+
+[tool.setuptools.package-data]
+"easydoc" = ["templates/*.md", "templates/*.html", "config/*.json"]
+
+[project.urls]
+Homepage = "https://github.com/epsilonkn/EasyDoc"
+Issues = "https://github.com/epsilonkn/EasyDoc/issues"

easydocpy-1.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+