placo 0.6.5__tar.gz → 0.7.1__tar.gz

{placo-0.6.5 → placo-0.7.1}/CMakeLists.txt

@@ -127,7 +127,7 @@ target_link_libraries(libplaco PUBLIC
     ${PROTOBUF_LIBRARIES}
   ${PROTOBUF_LIBRARIES}
 )
-target_compile_definitions(libplaco PUBLIC -DPINOCCHIO_WITH_HPP_FCL)
+target_compile_definitions(libplaco PUBLIC)
 
 if(TARGET rhoban_utils)
   message("Placo: Rhoban utils is present, enabling it")
@@ -139,6 +139,7 @@ set(CMAKE_SHARED_MODULE_PREFIX "")
 
 find_package(Python3 REQUIRED)
 find_package(Boost COMPONENTS python REQUIRED)
+find_package(Python REQUIRED COMPONENTS Interpreter)
 
 add_library(placo MODULE 
     bindings/expose-eigen.cpp
@@ -151,7 +152,7 @@ add_library(placo MODULE
     bindings/expose-walk-pattern-generator.cpp
     bindings/expose-dynamics.cpp
     bindings/module.cpp
-    bindings/registry.cpp
+    bindings/doxystub/registry.cpp
 )
 set_target_properties(placo PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB})
 
@@ -159,8 +160,13 @@ target_link_libraries(placo ${Boost_LIBRARIES} ${PYTHON_LIBRARIES} libplaco)
 target_include_directories(placo PRIVATE ${PYTHON_INCLUDE_DIRS})
 
 add_custom_command(TARGET placo POST_BUILD
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/stubs.py > placo.pyi
-    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}
+    COMMAND 
+    "${Python_EXECUTABLE}"
+    ${CMAKE_CURRENT_SOURCE_DIR}/bindings/doxystub/stubs.py
+    placo
+    "${CMAKE_CURRENT_SOURCE_DIR}"
+    "${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}/placo.pyi"
+    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}"
     COMMENT "Generating stubs..."
 )
 
@@ -175,4 +181,4 @@ set_target_properties(libplaco PROPERTIES INSTALL_RPATH "\$ORIGIN")
 install(TARGETS libplaco DESTINATION lib)
 install(TARGETS placo DESTINATION ${PYTHON_SITELIB})
 install(FILES ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}/placo.pyi DESTINATION ${PYTHON_SITELIB})
-install(DIRECTORY ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}/placo_utils DESTINATION ${PYTHON_SITELIB})
+install(DIRECTORY ${CMAKE_BINARY_DIR}/${PYTHON_SITELIB}/placo_utils DESTINATION ${PYTHON_SITELIB})

{placo-0.6.5 → placo-0.7.1}/Makefile

@@ -2,7 +2,7 @@
 # Building Python wheel
 all:
 	@rm -rf dist/*
-	python -m build --sdist --wheel
+	bash build_wheel.sh
 	bash tweak_sdist.sh
 
 upload:

{placo-0.6.5 → placo-0.7.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: placo
-Version: 0.6.5
+Version: 0.7.1
 Summary: PlaCo: Rhoban Planning and Control
-Requires-Python: >= 3.8
+Requires-Python: >= 3.9
 License-Expression: MIT
 Author-email: Rhoban team <team@rhoban.com>
 Project-URL: Changelog, https://github.com/rhoban/placo/blob/main/CHANGELOG.md
@@ -10,14 +10,12 @@ Home-page: https://placo.readthedocs.io/en/latest/
 Project-URL: Repository, https://github.com/rhoban/placo.git
 Requires-Dist: cmeel
 Requires-Dist: eiquadprog >= 1.2.6, < 2
-Requires-Dist: pin >= 2.6.18, < 3
+Requires-Dist: pin >= 3
 Requires-Dist: rhoban-cmeel-jsoncpp
 Requires-Dist: meshcat
-Requires-Dist: numpy<2
 Requires-Dist: ischedule
 Provides-Extra: build
-Requires-Dist: pin[build] >= 2.6.18, < 3 ; extra == "build"
-Requires-Dist: cmeel-urdfdom[build] ; extra == "build"
+Requires-Dist: pin[build] >=  3 ; extra == "build"
 Description-Content-Type: text/markdown
 
 <img width="400" src="https://placo.readthedocs.io/en/latest/_static/placo.png" />

placo-0.7.1/bindings/doxystub/README.md

@@ -0,0 +1,15 @@
+# Generate Doxygen stubs 
+
+This code allow to generate a `module.pyi` file containing useful auto-completion stubs, based on Doxygen and introspection.
+
+## Step1: configure your project
+
+In `config.py`, set the name of the module and the path to the source directory (where the `Doxyfile` is)
+
+## Step2: expose through registry
+
+Include `registry.h` in your Python bindings, and use `class__` instead of `class_`, so that the registered classes will be wrapped in the registry
+
+## Step3: call `stubs.py` after compilation
+
+Execute the `stubs.py` script after compilation, it will output the `pyi` file.

placo-0.7.1/bindings/doxystub/doxygen_parse.py

@@ -0,0 +1,301 @@
+import glob
+import re
+from typing import Union
+import xml.etree.ElementTree as ET
+
+
+def element_to_string(element: ET.Element) -> str:
+    """
+    Retrieve the contents of a given node
+    """
+    s = element.text or ""
+    for sub_element in element:
+        s += ET.tostring(sub_element).decode("utf-8")
+    s += element.tail
+    return re.sub("<[^<]+?>", "", s)
+
+
+def parse_type(node: ET.Element):
+    """
+    Retrieve the type of the object present in the given node
+    """
+    type_node = node.find("type")
+
+    if type_node.find("ref") is not None:
+        if type_node.text and "vector" in type_node.text:
+            return ["std::vector", type_node.find("ref").attrib["refid"]]
+        else:
+            return type_node.find("ref").attrib["refid"]
+    else:
+        return type_node.text
+
+
+class DoxygenElement:
+    def __init__(self, id: str, name: str):
+        self.id = id
+        self.name: str = name
+
+
+class DoxygenTypedef(DoxygenElement):
+    pass
+
+
+class DoxygenMember(DoxygenElement):
+    def __init__(self, id: str, name: str):
+        super().__init__(id, name)
+        self.static: bool = False
+        self.type: str | None = None
+        self.brief: str = ""
+
+    def parse(self, node: ET.Element):
+        self.static = node.attrib["static"] == "yes"
+
+        self.type = parse_type(node)
+
+        # Brief description
+        self.brief = node.find("briefdescription/para")
+        if self.brief is not None:
+            self.brief = element_to_string(self.brief)
+
+        # Verbatim
+        verbatim = node.find("detaileddescription/para/verbatim")
+        if verbatim is not None:
+            self.brief += "\n" + verbatim.text
+
+
+class DoxygenVariable(DoxygenMember):
+    pass
+
+
+class DoxygenParameter:
+    def __init__(self):
+        self.type = None
+        self.name = None
+        self.default_value = None
+        self.description = None
+
+    def parse(self, node: ET.Element):
+        self.type = parse_type(node)
+
+        if node.find("declname") is not None:
+            self.name = node.find("declname").text
+        if node.find("defname") is not None:
+            self.name = node.find("defname").text
+
+        self.default_value = (
+            node.find("defval").text if node.find("defval") is not None else None
+        )
+
+
+class DoxygenFunction(DoxygenMember):
+    def __init__(self, id: str, name: str, class_member: bool = False):
+        super().__init__(id, name)
+        self.params: list[DoxygenParameter] = []
+        self.returns_description = None
+        self.class_member = class_member
+
+    def parse(self, node: ET.Element):
+        super().parse(node)
+
+        # Searching for method parameters
+        for param in node.findall("param"):
+            parameter = DoxygenParameter()
+            parameter.parse(param)
+            self.params.append(parameter)
+
+        # Searching for detailed description to retrieve parameter descriptions
+        for entry in node.findall(
+            "detaileddescription/para/parameterlist/parameteritem"
+        ):
+            param_name = entry.find("parameternamelist/parametername").text
+            param_desc = element_to_string(entry.find("parameterdescription/para"))
+
+            for param in self.params:
+                if param.name == param_name:
+                    param.description = param_desc
+
+        # Description of method returns
+        return_desc = node.find("detaileddescription/para/simplesect[@kind='return']")
+        if return_desc:
+            self.returns_description = return_desc.find("para")
+
+
+class DoxygenCompound(DoxygenElement):
+    def __init__(self, id: str, name: str):
+        super().__init__(id, name)
+        self.brief: str | None = None
+        self.members: dict[str, DoxygenMember] = {}
+        self.types: dict[str, str] = {}
+        self.is_class: bool = False
+
+    def parse(self, node: ET.Element):
+        if node.find("briefdescription/para"):
+            self.brief = element_to_string(node.find("briefdescription/para"))
+
+        # Searching for member definitions
+        for member_node in node.findall("sectiondef/memberdef"):
+            # If @pyignore is added to the description, this member is skipped
+            ignore = False
+            sects = member_node.findall("detaileddescription/para/xrefsect")
+            if sects:
+                for sect in sects:
+                    if "pyignore" in sect.attrib["id"]:
+                        ignore = True
+            if ignore:
+                continue
+
+            kind = member_node.attrib["kind"]
+            id = member_node.attrib["id"]
+
+            member = None
+            if kind == "function":
+                member = DoxygenFunction(
+                    id, member_node.find("name").text, self.is_class
+                )
+                member.parse(member_node)
+            elif kind == "variable":
+                member = DoxygenVariable(id, member_node.find("name").text)
+                member.parse(member_node)
+            elif kind == "typedef":
+                self.types[id] = DoxygenTypedef(id, parse_type(member_node))
+            elif kind == "enum":
+                self.types[id] = DoxygenTypedef(
+                    id, self.name + "::" + member_node.find("name").text
+                )
+
+            if member is not None:
+                self.members[id] = member
+
+
+class DoxygenClass(DoxygenCompound):
+    def __init__(self, id: str, name: str):
+        super().__init__(id, name)
+        self.is_class: bool = True
+
+
+class DoxygenNamespace(DoxygenCompound):
+    def __init__(self, id: str, name: str):
+        super().__init__(id, name)
+
+
+class Doxygen:
+    def __init__(self):
+        self.compounds: dict[str, DoxygenCompound] = {}
+        self.elements: dict[str, DoxygenElement] = {}
+
+    def parse_directory(self, directory: str):
+        doxygen_xml_files = glob.glob(f"{directory}/xml/*.xml")
+
+        # Parsing all files
+        for xml_file in doxygen_xml_files:
+            self.parse_xml(xml_file)
+
+        # Collecting all elements (compounds, members and typedefs)
+        self.elements = self.compounds.copy()
+        for compound in self.compounds.values():
+            for element in list(compound.members.values()) + list(
+                compound.types.values()
+            ):
+                self.elements[element.id] = element
+
+        # Resolving member and parameter types
+        for compound in self.compounds.values():
+            for member in compound.members.values():
+                member.type = self.resolve_type(member.type)
+
+                if isinstance(member, DoxygenFunction):
+                    function: DoxygenFunction = member
+                    for param in member.params:
+                        param.type = self.resolve_type(param.type)
+
+    def resolve_type(self, id: Union[list, str]):
+        if type(id) == list:
+            tpl = self.resolve_type(id[0])
+            subtypes = [self.resolve_type(subid) for subid in id[1:]]
+            args = ",".join(subtypes)
+            return f"{tpl}<{args}>"
+        elif id in self.elements:
+            return self.elements[id].name
+        else:
+            return id
+
+    def parse_xml(self, filename: str):
+        with open(filename, "r") as f:
+            xml_content = f.read()
+            xml_content = ET.fromstring(xml_content)
+
+            # Searching for compounddef nodes (classs & struct)
+            for compounddef_node in xml_content.findall("compounddef"):
+                self.parse_compound(compounddef_node)
+
+    def parse_compound(self, compounddef_node: ET.Element):
+        name = compounddef_node.find("compoundname").text
+        compound_kind = compounddef_node.attrib["kind"]
+        id = compounddef_node.attrib["id"]
+
+        if compound_kind == "class" or compound_kind == "struct":
+            compound = DoxygenClass(id, name)
+        elif compound_kind == "namespace":
+            compound = DoxygenNamespace(id, name)
+        else:
+            return
+
+        compound.parse(compounddef_node)
+        self.compounds[id] = compound
+
+    def get_class(self, class_name: str) -> DoxygenClass | None:
+        for compound in self.compounds.values():
+            if compound.name == class_name:
+                return compound
+
+        return None
+
+    def get_class_member(
+        self, class_name: str, member_name: str
+    ) -> DoxygenMember | None:
+        class_ = self.get_class(class_name)
+
+        if class_ is not None:
+            for member in class_.members.values():
+                if member.name == member_name:
+                    return member
+
+        return None
+
+    def get_function(self, function_name: str) -> DoxygenFunction | None:
+        for compound in self.compounds.values():
+            if isinstance(compound, DoxygenNamespace):
+                for member in compound.members.values():
+                    if (
+                        isinstance(member, DoxygenFunction)
+                        and member.name == function_name
+                    ):
+                        return member
+
+        return None
+
+    def get_class_function(
+        self, class_name: str, function_name: str
+    ) -> DoxygenFunction | None:
+        member = self.get_class_member(class_name, function_name)
+
+        if isinstance(member, DoxygenFunction):
+            return member
+
+        return None
+
+    def get_class_variable(
+        self, class_name: str, function_name: str
+    ) -> DoxygenVariable | None:
+        member = self.get_class_member(class_name, function_name)
+
+        if isinstance(member, DoxygenVariable):
+            return member
+
+        return None
+
+
+if __name__ == "__main__":
+    # parse_directory(".")
+    doxygen = Doxygen()
+    doxygen.parse_directory(".")