lupin-danquin 0.0.1.dev0__tar.gz

lupin-danquin-0.0.1.dev0/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.

lupin-danquin-0.0.1.dev0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: lupin-danquin
+Version: 0.0.1.dev0
+Summary: Testing - Documentation VAL3 from Code
+License: MIT License
+Keywords: documentation,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Documentation
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Provides-Extra: test
+License-File: LICENCE

lupin-danquin-0.0.1.dev0/README.md

@@ -0,0 +1,38 @@
+# Documentation extraction
+
+## Purpose
+
+"documentation_extraction.py" Python script allow to create SDD documentation from source code.
+
+The goal is to replace the hand written wiki page accessible here: https://gitlab.com/lupindental/arsene/robotics/production/lupin.robot.staubli/-/wikis/Software-Detailed-Design-Robot-Application-unit
+
+## Run it
+
+1. Go to current directory.
+2. Execute
+> python documentation_extraction.py
+3. Result is available in "./val3_documentation.md"
+
+## Add documentation
+
+### For a program (pgx file)
+
+Edit your program and add one or more lines of comments the line after "begin" keyword.
+
+### For an application
+
+Create a text file named "README.md" at the same level as "pjx" file. And add one or more lines of description.
+
+## Improvements oportunities
+
+- Improve table for sockets
+- Allow to end docstring with 10 * "/"
+
+## Other ideas
+
+To create a sanitizer:
+
+- detect unused variables (private, public?): already done for local variables and parameters (not global variables)
+- detect wrongly named variables (l_, x_, s/b/n/st, t, Out): DONE
+- validate plantuml diagram from pjx files
+- code coverage ? find if all return values are tested

lupin-danquin-0.0.1.dev0/lupin_danquin/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1.dev0"

lupin-danquin-0.0.1.dev0/lupin_danquin/check_coding_rules.py

@@ -0,0 +1,31 @@
+import os
+
+from core.application import Application
+
+
+if __name__ == "__main__":
+    base_program_path = (
+        os.path.abspath(os.path.dirname(__file__) + r"/../../danquin/val3/usrapp/")
+        + "/"
+    )
+    application_names = [
+        "TaskManager",
+    ]
+    result = []
+    for application_name in application_names:
+        program_path = base_program_path + application_name
+        app = Application(program_path, application_name)
+        result += app.check_coding_rules()
+
+    if len(result) > 0:
+        print(f"{len(result)} errors found while checking coding rules:")
+        print()
+        print(
+            """
+        """.join(
+                result
+            )
+        )
+    else:
+        print("No error found while checking coding rules.")
+    exit(len(result))

lupin-danquin-0.0.1.dev0/lupin_danquin/core/application.py

@@ -0,0 +1,126 @@
+from typing import Any, Dict, List
+from xml.dom import minidom
+
+from .global_variable import GlobalVariable
+from .program import Program
+from .line_ended import LINE_ENDED
+
+
+def get_program_list(
+    program_path,
+    application_name,
+    exclude=["UT.pgx", "start.pgx", "stop.pgx", "test.pgx"],
+) -> List[Program]:
+    file_path = program_path + "/" + application_name + ".pjx"
+    doc = minidom.parse(file_path)
+    progs = doc.getElementsByTagName("Program")
+    return_progs = []
+    for prog in progs:
+        name = prog.getAttribute("file")
+        should_exclude = False
+        for e in exclude:
+            if e in name:
+                should_exclude = True
+        if not should_exclude:
+            return_progs.append(Program(program_path, name))
+    return return_progs
+
+
+def get_dependencies(program_path, application_name, exclude=["Logger"]) -> List[str]:
+    file_path = program_path + "/" + application_name + ".pjx"
+    doc = minidom.parse(file_path)
+    deps = doc.getElementsByTagName("Library")
+    return_deps = []
+    for dep in deps:
+        name = dep.getAttribute("alias")
+        should_exclude = False
+        for e in exclude:
+            if e in name:
+                should_exclude = True
+        if not should_exclude:
+            return_deps.append(name)
+    return return_deps
+
+
+def get_type_dependencies(
+    program_path, application_name, exclude=["Logger"]
+) -> List[str]:
+    file_path = program_path + "/" + application_name + ".pjx"
+    doc = minidom.parse(file_path)
+    deps = doc.getElementsByTagName("Type")
+    return_deps = []
+    for dep in deps:
+        name = dep.getAttribute("name")
+        should_exclude = False
+        for e in exclude:
+            if e in name:
+                should_exclude = True
+        if not should_exclude:
+            return_deps.append(name)
+    return return_deps
+
+
+def get_global_variables(
+    program_path, application_name, exclude=["UT"]
+) -> List[GlobalVariable]:
+    file_path = program_path + "/" + application_name + ".dtx"
+    doc = minidom.parse(file_path)
+    vars = doc.getElementsByTagName("Data")
+    return_vars = []
+    for var in vars:
+        name = var.getAttribute("name")
+        should_exclude = False
+        for e in exclude:
+            if e in name:
+                should_exclude = True
+        if not should_exclude:
+            xsi = var.getAttribute("xsi:type")
+            access = var.getAttribute("access")
+            type_ = var.getAttribute("type")
+            size = var.getAttribute("size")
+            return_vars.append(
+                GlobalVariable(name, access, type_, xsi, size, file_path)
+            )
+    return return_vars
+
+
+def get_application_description(program_path) -> str:
+    file_path = program_path + "/README.md"
+    lines = []
+    try:
+        with open(file_path, "r") as f:
+            lines = f.readlines()
+    except FileNotFoundError:
+        print("Missing documentation file " + file_path)
+    return LINE_ENDED.join(lines)
+
+
+class Application:
+    def __init__(self, program_path: str, application_name: str):
+        self.application_name = application_name
+        self.dependencies = get_dependencies(program_path, application_name)
+        self.type_dependencies = get_type_dependencies(program_path, application_name)
+        self.program_list = get_program_list(program_path, application_name)
+        self.global_variables = get_global_variables(program_path, application_name)
+        self.application_description = get_application_description(program_path)
+
+    def check_coding_rules(self) -> List[str]:
+        result = []
+        for p in self.program_list:
+            result += p.check_coding_rules()
+        for gv in self.global_variables:
+            result += gv.check_coding_rules()
+        return result
+
+    def get_all_information_from_app(self) -> Dict[str, Any]:
+        """Return all information from the application in a dict for the documentation generation"""
+        all_information = {
+            "name": self.application_name,
+            "description": self.application_description,
+            "dependencies": self.dependencies,
+            "type_dependencies": self.type_dependencies,
+            "global_variables": self.global_variables,
+            "private_program_list": [p for p in self.program_list if not p.public],
+            "public_program_list": [p for p in self.program_list if p.public],
+        }
+        return all_information

lupin-danquin-0.0.1.dev0/lupin_danquin/core/external_resources.py

@@ -0,0 +1,18 @@
+import codecs
+import os
+
+
+def read_begining_of_file() -> str:
+    result = ""
+    path = os.path.dirname(__file__) + os.sep + ".." + os.sep + "assets" + os.sep
+    with codecs.open(path + "BeginingOfFile.md", encoding="utf-8") as f:
+        result = f.read()
+    return result
+
+
+def read_end_of_file() -> str:
+    result = ""
+    path = os.path.dirname(__file__) + os.sep + ".." + os.sep + "assets" + os.sep
+    with codecs.open(path + "EndOfFile.md", encoding="utf-8") as f:
+        result = f.read()
+    return result

lupin-danquin-0.0.1.dev0/lupin_danquin/core/global_variable.py

@@ -0,0 +1,52 @@
+from typing import List
+
+from .rules import OTHER_TYPES, TYPE_RULES
+
+
+class GlobalVariable:
+    def __init__(
+        self,
+        name: str,
+        access: str,
+        type_data: str,
+        xsi: str,
+        size: str,
+        context: str = "",
+    ):
+        self.name = name
+        self.type_data = type_data
+        self.xsi = xsi
+        self.size = size
+        self.access = access
+        self.context = context
+
+    def check_coding_rules(self) -> List:
+        result = []
+        if self.access == "private" and not self.name.startswith("_"):
+            result += [
+                f"Global private variable {self.name} should begin by '_'. {self.context}"
+            ]
+        if self.access != "private" and self.name.startswith("_"):
+            result += [
+                f"Global public variable {self.name} should not begin by '_'. {self.context}"
+            ]
+
+        name = self.name[1:] if self.name.startswith("_") else self.name
+        if self.type_data in TYPE_RULES.keys():
+            rule = TYPE_RULES.get(self.type_data)
+            if not name.startswith(rule):
+                result += [
+                    (
+                        f"Global variable {self.name} of type {self.type_data} should begin by "
+                        f"'{'_' if self.access == 'private' else ''}{rule}'. {self.context}"
+                    )
+                ]
+        else:
+            if not name.startswith(OTHER_TYPES):
+                result += [
+                    (
+                        f"Global variable {self.name} of type CUSTOM should begin by "
+                        f"'{'_' if self.access == 'private' else ''}{OTHER_TYPES}'. {self.context}"
+                    )
+                ]
+        return result

lupin-danquin-0.0.1.dev0/lupin_danquin/core/line_ended.py

@@ -0,0 +1,2 @@
+LINE_ENDED = """
+"""

lupin-danquin-0.0.1.dev0/lupin_danquin/core/local_variable.py

@@ -0,0 +1,35 @@
+from typing import List
+
+from .rules import OTHER_TYPES, TYPE_RULES
+
+
+class LocalVariable:
+    def __init__(
+        self, name: str, type_data: str, xsi: str, size: str, context: str = ""
+    ):
+        self.name = name
+        self.type_data = type_data
+        self.xsi = xsi
+        self.size = size
+        self.context = context
+
+    def check_coding_rules(self) -> List:
+        result = []
+        if not self.name.startswith("l_"):
+            result += [
+                f"Local variable {self.name} should begin by 'l_'. {self.context}"
+            ]
+
+        if self.type_data in TYPE_RULES.keys():
+            rule = TYPE_RULES.get(self.type_data)
+            if not self.name.startswith("l_" + rule):
+                result += [
+                    f"Local variable {self.name} of type {self.type_data} should begin by 'l_{rule}'. {self.context}"
+                ]
+        else:
+            if not self.name.startswith("l_" + OTHER_TYPES):
+                result += [
+                    f"Local variable {self.name} of type CUSTOM should begin by 'l_{OTHER_TYPES}'. {self.context}"
+                ]
+
+        return result

lupin-danquin-0.0.1.dev0/lupin_danquin/core/parameter.py

@@ -0,0 +1,42 @@
+from typing import List
+
+from .rules import OTHER_TYPES, TYPE_RULES
+
+
+class Parameter:
+    def __init__(
+        self, name: str, type_data: str, xsi: str, use: str, context: str = ""
+    ):
+        self.name = name
+        self.type_data = type_data
+        self.xsi = xsi
+        self.use = use
+        if len(use) == 0:
+            self.use = "value"
+        self.context = context
+
+    def check_coding_rules(self) -> List:
+        result = []
+        if not self.name.startswith("x_"):
+            result += [f"Parameter {self.name} should begin by 'x_'.  {self.context}"]
+        if (
+            self.use != "value"
+            and self.xsi == "element"
+            and not self.name.endswith("Out")
+        ):
+            result += [
+                f"Output parameter {self.name} should ends by 'Out'. {self.context}"
+            ]
+
+        if self.type_data in TYPE_RULES.keys():
+            rule = TYPE_RULES.get(self.type_data)
+            if not self.name.startswith("x_" + rule):
+                result += [
+                    f"Parameter {self.name} of type {self.type_data} should begin by 'x_{rule}'. {self.context}"
+                ]
+        else:
+            if not self.name.startswith("x_" + OTHER_TYPES):
+                result += [
+                    f"Parameter {self.name} of type CUSTOM should begin by 'x_{OTHER_TYPES}'. {self.context}"
+                ]
+        return result

lupin-danquin-0.0.1.dev0/lupin_danquin/core/program.py

@@ -0,0 +1,135 @@
+from typing import List
+from xml.dom import minidom
+
+from .parameter import Parameter
+from .local_variable import LocalVariable
+
+
+def get_parameters(program_path: str, program_file: str) -> List[Parameter]:
+    file_path = program_path + "/" + program_file
+    doc = minidom.parse(file_path)
+    params = doc.getElementsByTagName("Parameter")
+    returned_params = []
+    for param in params:
+        returned_params.append(
+            Parameter(
+                param.getAttribute("name"),
+                param.getAttribute("type"),
+                param.getAttribute("xsi:type"),
+                param.getAttribute("use"),
+                file_path,
+            )
+        )
+    return returned_params
+
+
+def get_program_description(program_path: str, program_file: str) -> str:
+    file_path = program_path + "/" + program_file
+    input_txt = []
+    with open(file_path, "r") as f_input:
+        input_txt = f_input.readlines()
+    comment_txt = r"//"
+    doc = ""
+    start_doc = False
+    for line in input_txt:
+        if start_doc:
+            if comment_txt in line:
+                doc += line.split(comment_txt)[-1]
+            else:
+                break
+        # first code line
+        if "<Code><![CDATA[begin" in line:
+            start_doc = True
+        # last code line
+        if "end]]></Code>" in line:
+            break
+    if len(doc) == 0:
+        print("Missing description for program " + file_path)
+    return doc
+
+
+def get_code(program_path: str, program_file: str) -> str:
+    file_path = program_path + "/" + program_file
+    input_txt = ""
+    with open(file_path, "r") as f_input:
+        input_txt = f_input.read()
+    return input_txt.split("<Code><![CDATA[begin")[-1].split("end]]></Code>")[0]
+
+
+def is_public(program_path: str, program_file: str) -> bool:
+    file_path = program_path + "/" + program_file
+    doc = minidom.parse(file_path)
+    prog = doc.getElementsByTagName("Program")
+    for p in prog:
+        return p.getAttribute("access") == "public"
+    return False
+
+
+def get_local_variables(program_path: str, program_file: str) -> List[LocalVariable]:
+    file_path = program_path + "/" + program_file
+    doc = minidom.parse(file_path)
+    vars = doc.getElementsByTagName("Local")
+    returned_vars = []
+    for var in vars:
+        returned_vars.append(
+            LocalVariable(
+                var.getAttribute("name"),
+                var.getAttribute("type"),
+                var.getAttribute("xsi:type"),
+                var.getAttribute("size"),
+                file_path,
+            )
+        )
+    return returned_vars
+
+
+def get_program_signature(program_name: str, parameters: List[Parameter]) -> str:
+    return (
+        program_name.removesuffix(".pgx")
+        + "("
+        + ", ".join(
+            [
+                param.type_data
+                + ("& " if (param.use == "reference") else " ")
+                + param.name
+                for param in parameters
+            ]
+        )
+        + ")"
+    )
+
+
+class Program:
+    def __init__(self, program_path: str, program_name: str):
+        self.program_path = program_path
+        self.program_name = program_name
+        self.param_list = get_parameters(program_path, program_name)
+        self.variable_list = get_local_variables(program_path, program_name)
+        self.description = get_program_description(program_path, program_name)
+        self.signature = get_program_signature(program_name, self.param_list)
+        self.public = is_public(program_path, program_name)
+        self.code = get_code(program_path, program_name)
+        self.check_has_unused_parameter()
+        self.check_has_unused_variable()
+
+    def check_coding_rules(self) -> List[str]:
+        return self.check_has_unused_parameter() + self.check_has_unused_variable()
+
+    def check_has_unused_parameter(self) -> List[str]:
+        result = []
+        for param in self.param_list:
+            if param.name not in self.code:
+                result += [
+                    f"Unused parameter {param.name} in program {self.program_path}/{self.program_name}"
+                ]
+            result += param.check_coding_rules()
+        return result
+
+    def check_has_unused_variable(self) -> List[str]:
+        result = []
+        for var in self.variable_list:
+            if var.name not in self.code:
+                result += [
+                    f"Unused local variable {var.name} in program {self.program_path}/{self.program_name}"
+                ]
+        return result

lupin-danquin-0.0.1.dev0/lupin_danquin/core/rules.py

@@ -0,0 +1,19 @@
+TYPE_RULES = {
+    "aio": "aio",
+    "bool": "b",
+    "configRs": "c",
+    "configRx": "c",
+    "dio": "dio",
+    "frame": "f",
+    "jointRs": "j",
+    "jointRx": "j",
+    "mdesc": "m",
+    "num": "n",
+    "pointRs": "p",
+    "pointRx": "p",
+    "sio": "sio",
+    "string": "s",
+    "tool": "t",
+    "trsf": "trsf",
+}
+OTHER_TYPES = "st"

lupin-danquin-0.0.1.dev0/lupin_danquin/core/tools/utils.py

@@ -0,0 +1,37 @@
+import logging
+import re
+import sys
+
+
+def configure_logging():
+    logging.basicConfig(
+        format="%(asctime)s %(levelname)s: %(message)s", level=logging.INFO
+    )
+
+
+def die(msg: str) -> None:
+    logging.error(msg)
+    sys.exit(1)
+
+
+def get_version():
+    """get version from setup.cfg file and
+    update __version__ in lupin_danquin.__init__.py
+    """
+    with open("setup.cfg", "r", encoding="utf-8") as f:
+        setup_cfg = f.read()
+    print(setup_cfg)
+    _version = re.search(
+        r"(^version = )(\d{1,2}\.\d{1,2}\.\d{1,2})(\.[a-z]{1,})?(\d{1,2})?",
+        setup_cfg,
+        re.MULTILINE,
+    )
+    version = ""
+    for group in _version.group(2, 3, 4):
+        if group is not None:
+            version = version + str(group)
+    content = f'__version__ = "{version}"\n'
+
+    with open("lupin_danquin/__init__.py", "w", encoding="utf-8") as outfile:
+        outfile.write(content)
+    return version

lupin-danquin-0.0.1.dev0/lupin_danquin/core/val3_doc_generator/val3_doc_generator.py

@@ -0,0 +1,45 @@
+import codecs
+
+from jinja2 import (
+    Environment,
+    FileSystemLoader,
+    select_autoescape,
+    Template,
+    TemplateNotFound,
+    TemplateError,
+    TemplateRuntimeError,
+)
+
+from core.tools.utils import die
+
+
+class Val3Documentation:
+    def _get_local_template(self) -> Template:
+        try:
+            # Create jinja2 environment
+            env = Environment(
+                loader=FileSystemLoader("lupin_danquin/templates"),
+                autoescape=select_autoescape(),
+                trim_blocks=True,
+                lstrip_blocks=True,
+            )
+            # Charge template
+            template = env.get_template("val3_documentation_md.j2")
+            return template
+        except TemplateNotFound:
+            print(
+                "Template 'lupin_danquin/templates/val3_documentation_md.j2 not found"
+            )
+
+    def generate_markdown(self, context={}) -> None:
+        """Generate the documentation"""
+        template = self._get_local_template()
+        try:
+            content = template.render(context)
+        except (TemplateError, TemplateRuntimeError) as e:
+            die(msg=f"Error rendering Jinja2 template: {e}")
+
+        with codecs.open(
+            "lupin_danquin/val3_documentation.md", "w", encoding="utf-8"
+        ) as f:
+            f.write(content)

lupin-danquin-0.0.1.dev0/lupin_danquin/documentation_extraction.py

@@ -0,0 +1,54 @@
+import os
+
+from core.application import Application
+from core.external_resources import read_begining_of_file, read_end_of_file
+from core.tools.utils import configure_logging, die
+from core.val3_doc_generator.val3_doc_generator import Val3Documentation
+
+
+APPLICATION_NAMES = [
+    "TaskManager",
+    "Watchdog",
+]
+USR_APP_DIR = "usrapp"
+
+
+def find_usrapp_dir() -> str:
+    """Find the usrapp directory"""
+    for dirpath, dirnames, filenames in os.walk(os.getcwd()):
+        if USR_APP_DIR in dirnames:
+            return os.path.join(dirpath, USR_APP_DIR)
+    die(msg=f"'{USR_APP_DIR}' directory not found")
+
+
+def get_informations_from_applications() -> list:
+    """Get all informations from applications"""
+
+    apps_information = []
+    base_program_path = find_usrapp_dir() + os.sep
+
+    for application_name in APPLICATION_NAMES:
+        program_path = base_program_path + application_name
+        apps_information.append(
+            Application(program_path, application_name).get_all_information_from_app()
+        )
+
+    return apps_information
+
+
+def main() -> None:
+    """Main function"""
+
+    configure_logging()
+
+    context = {
+        "begining_of_file": read_begining_of_file(),
+        "end_of_file": read_end_of_file(),
+        "applications": get_informations_from_applications(),
+    }
+
+    Val3Documentation().generate_markdown(context=context)
+
+
+if __name__ == "__main__":
+    main()

lupin-danquin-0.0.1.dev0/lupin_danquin.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: lupin-danquin
+Version: 0.0.1.dev0
+Summary: Testing - Documentation VAL3 from Code
+License: MIT License
+Keywords: documentation,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Documentation
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Provides-Extra: test
+License-File: LICENCE

lupin-danquin-0.0.1.dev0/lupin_danquin.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENCE
+README.md
+setup.cfg
+setup.py
+lupin_danquin/__init__.py
+lupin_danquin/check_coding_rules.py
+lupin_danquin/documentation_extraction.py
+lupin_danquin.egg-info/PKG-INFO
+lupin_danquin.egg-info/SOURCES.txt
+lupin_danquin.egg-info/dependency_links.txt
+lupin_danquin.egg-info/not-zip-safe
+lupin_danquin.egg-info/requires.txt
+lupin_danquin.egg-info/top_level.txt
+lupin_danquin/core/__init__.py
+lupin_danquin/core/application.py
+lupin_danquin/core/external_resources.py
+lupin_danquin/core/global_variable.py
+lupin_danquin/core/line_ended.py
+lupin_danquin/core/local_variable.py
+lupin_danquin/core/parameter.py
+lupin_danquin/core/program.py
+lupin_danquin/core/rules.py
+lupin_danquin/core/tools/__init__.py
+lupin_danquin/core/tools/utils.py
+lupin_danquin/core/val3_doc_generator/__init__.py
+lupin_danquin/core/val3_doc_generator/val3_doc_generator.py

lupin-danquin-0.0.1.dev0/lupin_danquin.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lupin-danquin-0.0.1.dev0/lupin_danquin.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

lupin-danquin-0.0.1.dev0/lupin_danquin.egg-info/requires.txt

@@ -0,0 +1,7 @@
+typer[all]==0.7.0
+python-dotenv==1.0.0
+Jinja2==3.1.2
+
+[test]
+pytest==7.2.2
+flake8==6.0.0

lupin-danquin-0.0.1.dev0/lupin_danquin.egg-info/top_level.txt

@@ -0,0 +1 @@
+lupin_danquin

lupin-danquin-0.0.1.dev0/setup.cfg

@@ -0,0 +1,37 @@
+[metadata]
+name = lupin-danquin
+version = 0.0.1.dev0
+description = Testing - Documentation VAL3 from Code
+keywords = documentation, testing
+license = MIT License
+classifiers = 
+	Development Status :: 3 - Alpha
+	Intended Audience :: Information Technology
+	Topic :: Software Development :: Testing
+	Topic :: Documentation
+	Programming Language :: Python :: 3.10
+	License :: OSI Approved :: MIT License
+
+[options]
+zip_safe = False
+include_package_data = True
+packages = find:
+python_requires = >=3.10
+install_requires = 
+	typer[all]==0.7.0
+	python-dotenv==1.0.0
+	Jinja2==3.1.2
+
+[options.extras_require]
+test = 
+	pytest==7.2.2
+	flake8==6.0.0
+
+[options.packages.find]
+exclude = 
+	lupin_danquin.tests*
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

lupin-danquin-0.0.1.dev0/setup.py

@@ -0,0 +1,10 @@
+from setuptools import setup
+
+
+from lupin_danquin.core.tools.utils import get_version
+
+
+if __name__ == '__main__':
+    setup(
+        version=get_version()
+    )