xrobot 0.1.0__tar.gz

xrobot-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

xrobot-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: xrobot
+Version: 0.1.0
+Summary: A Python package for parsing IOC files and generating C++ code.
+Author-email: Xiao <2592509183@qq.com>
+Maintainer-email: Xiao <2592509183@qq.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/xrobot-org
+Project-URL: Documentation, https://xrobot-org.github.io
+Project-URL: Repository, https://github.com/xrobot-org/XRobot
+Project-URL: Bug Tracker, https://github.com/xrobot-org/XRobot/issues
+Keywords: code generation,embedded systems,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argparse
+Requires-Dist: pyyaml
+Provides-Extra: gui
+Requires-Dist: PyQt5; extra == "gui"
+Provides-Extra: cli
+Requires-Dist: rich; extra == "cli"
+Requires-Dist: click; extra == "cli"
+Dynamic: license-file

xrobot-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xrobot"
+version = "0.1.0"
+description = "A Python package for parsing IOC files and generating C++ code."
+requires-python = ">=3.8"
+authors = [
+    {name = "Xiao", email = "2592509183@qq.com"}
+]
+maintainers = [
+    {name = "Xiao", email = "2592509183@qq.com"}
+]
+readme = "README.md"
+license = {text = "Apache-2.0"}
+keywords = ["code generation", "embedded systems", "automation"]
+dependencies = [
+    "argparse",
+    "pyyaml"
+]
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+gui = ["PyQt5"]
+cli = ["rich", "click"]
+
+[project.urls]
+Homepage = "https://github.com/xrobot-org"
+Documentation = "https://xrobot-org.github.io"
+Repository = "https://github.com/xrobot-org/XRobot"
+"Bug Tracker" = "https://github.com/xrobot-org/XRobot/issues"
+
+[project.scripts]
+xrobot_gen_main = "xrobot.GenerateMain:main"
+xrobot_mod_parser = "xrobot.ModuleParser:main"
+xrobot_create_mod = "xrobot.ModuleCreator:main"
+xrobot_init_mod = "xrobot.InitModule:main"
+xrobot_setup = "xrobot.XRobotSetup:main"
+xrobot_add_mod = "xrobot.AddModule:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

xrobot-0.1.0/setup.cfg

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

xrobot-0.1.0/src/xrobot/AddModule.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+xrobot_add_mod.py - 添加模块仓库或追加模块实例配置
+
+Usage 示例：
+  # 添加模块仓库（默认写入 Modules/modules.yaml）
+  python xrobot_add_mod.py https://github.com/yourorg/BlinkLED.git --version main
+
+  # 追加模块实例（默认写入 User/xrobot.yaml）
+  python xrobot_add_mod.py BlinkLED
+"""
+
+import argparse
+import yaml
+from pathlib import Path
+from urllib.parse import urlparse
+from collections import OrderedDict
+
+DEFAULT_REPO_CONFIG = Path("Modules/modules.yaml")
+DEFAULT_INSTANCE_CONFIG = Path("User/xrobot.yaml")
+MODULES_DIR = Path("Modules")
+
+def is_repo_url(s: str) -> bool:
+    return s.startswith("http://") or s.startswith("https://")
+
+def extract_name_from_repo(repo: str) -> str:
+    return Path(urlparse(repo).path).stem
+
+def load_yaml(path: Path) -> dict:
+    return yaml.safe_load(path.read_text(encoding="utf-8")) if path.exists() else {}
+
+def save_yaml(path: Path, data: dict):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.dump(data, sort_keys=False, allow_unicode=True), encoding="utf-8")
+
+def parse_manifest_from_header(header_path: Path) -> dict:
+    content = header_path.read_text(encoding="utf-8")
+    lines = content.splitlines()
+    block = []
+    inside = False
+
+    for line in lines:
+        stripped = line.strip()
+        if stripped == "/* === MODULE MANIFEST ===":
+            inside = True
+            continue
+        if stripped == "=== END MANIFEST === */":
+            break
+        if inside:
+            block.append(line.replace("/*", "  ").replace("*/", "  ").rstrip())
+
+    try:
+        return yaml.safe_load("\n".join(block)) or {}
+    except yaml.YAMLError as e:
+        print(f"[ERROR] Failed to parse manifest: {e}")
+        return {}
+
+def append_module_instance(module_name: str, config_path: Path):
+    header_path = MODULES_DIR / module_name / f"{module_name}.hpp"
+    if not header_path.exists():
+        print(f"[ERROR] Module header not found: {header_path}")
+        return
+
+    manifest = parse_manifest_from_header(header_path)
+    args = manifest.get("constructor_args", {})
+    args_ordered = OrderedDict()
+    if isinstance(args, dict):
+        args_ordered.update(args)
+    elif isinstance(args, list):
+        for item in args:
+            if isinstance(item, dict):
+                args_ordered.update(item)
+
+    data = load_yaml(config_path)
+    if "modules" not in data or not isinstance(data["modules"], list):
+        data["modules"] = []
+
+    data["modules"].append({
+        "name": module_name,
+        "constructor_args": dict(args_ordered)
+    })
+
+    save_yaml(config_path, data)
+    print(f"[SUCCESS] Appended module instance '{module_name}' to {config_path}")
+
+def add_repo_entry(repo: str, version: str, config_path: Path):
+    name = extract_name_from_repo(repo)
+    data = load_yaml(config_path)
+    modules = data.get("modules", [])
+
+    if any(m.get("name") == name for m in modules):
+        print(f"[WARN] Module '{name}' already exists in {config_path}. Skipping.")
+        return
+
+    entry = {"name": name, "repo": repo}
+    if version:
+        entry["version"] = version
+    modules.append(entry)
+
+    save_yaml(config_path, {"modules": modules})
+    print(f"[SUCCESS] Added repo module '{name}' to {config_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Add module repo or instance config to YAML")
+    parser.add_argument("target", help="Repo URL or local module name")
+    parser.add_argument("--version", "-v", help="Branch or tag (repo only)")
+    parser.add_argument("--config", "-c", help="YAML file path to write (auto default)")
+
+    args = parser.parse_args()
+
+    # 判断类型并选择默认 config 路径
+    if is_repo_url(args.target):
+        config_path = Path(args.config) if args.config else DEFAULT_REPO_CONFIG
+        add_repo_entry(args.target, args.version, config_path)
+    else:
+        config_path = Path(args.config) if args.config else DEFAULT_INSTANCE_CONFIG
+        append_module_instance(args.target, config_path)
+
+if __name__ == "__main__":
+    main()

xrobot-0.1.0/src/xrobot/GenerateMain.py

@@ -0,0 +1,195 @@
+import yaml
+import argparse
+from pathlib import Path
+from collections import OrderedDict
+from typing import Union, Dict, List
+
+
+def parse_manifest_from_header(header_path: Path) -> Dict:
+    """Extract and parse manifest data from module header file."""
+    content = header_path.read_text(encoding="utf-8")
+    manifest_block = []
+    in_manifest = False
+
+    for line in content.splitlines():
+        stripped = line.strip()
+        if stripped == "/* === MODULE MANIFEST ===":
+            in_manifest = True
+            continue
+        if stripped == "=== END MANIFEST === */":
+            break
+        if in_manifest:
+            cleaned_line = line.replace("/*", "  ").replace("*/", "  ").rstrip()
+            manifest_block.append(cleaned_line)
+
+    try:
+        manifest_data = yaml.safe_load("\n".join(manifest_block)) or {}
+    except yaml.YAMLError as e:
+        print(f"[ERROR] YAML parsing failed: {str(e)}")
+        return {}
+
+    if 'constructor_args' in manifest_data:
+        raw_args = manifest_data['constructor_args']
+        ordered_args = OrderedDict()
+
+        if isinstance(raw_args, dict):
+            ordered_args.update(raw_args)
+        elif isinstance(raw_args, list):
+            for item in raw_args:
+                if isinstance(item, dict):
+                    ordered_args.update(item)
+        else:
+            print(f"[WARN] Unsupported constructor_args type: {type(raw_args)}")
+
+        manifest_data['constructor_args'] = ordered_args
+
+    return manifest_data
+
+
+def _format_cpp_value(value: Union[dict, list, str, int, float, bool]) -> str:
+    """Generate C++-compliant parameter values."""
+    if isinstance(value, dict):
+        inner = ", ".join(_format_cpp_value(v) for _, v in value.items())
+        return f"{{{inner}}}"
+    elif isinstance(value, list):
+        return "{" + ", ".join(_format_cpp_value(v) for v in value) + "}"
+    elif isinstance(value, bool):
+        return "true" if value else "false"
+    elif isinstance(value, str):
+        return f'"{value}"'
+    else:
+        return str(value)
+
+
+def extract_constructor_args(modules: List[str], module_dir: Path, config_path: Path) -> Dict:
+    """Extract default constructor_args for each module and save to YAML in list format."""
+    output = {
+        "global_settings": {
+            "monitor_sleep_ms": 1000
+        },
+        "modules": []
+    }
+
+    for mod in modules:
+        hpp_path = module_dir / mod / f"{mod}.hpp"
+        if not hpp_path.exists():
+            print(f"[WARN] Header not found for module: {mod}")
+            continue
+
+        manifest = parse_manifest_from_header(hpp_path)
+        args_raw = manifest.get("constructor_args", {})
+        args_ordered = OrderedDict()
+
+        if isinstance(args_raw, dict):
+            args_ordered.update(args_raw)
+        elif isinstance(args_raw, list):
+            for item in args_raw:
+                if isinstance(item, dict):
+                    args_ordered.update(item)
+
+        # Append as new module instance
+        output["modules"].append({
+            "name": mod,
+            "constructor_args": dict(args_ordered)
+        })
+
+    config_path.write_text(
+        yaml.dump(output, sort_keys=False, allow_unicode=True, indent=2),
+        encoding="utf-8"
+    )
+
+    return output
+
+
+def generate_xrobot_main_code(hw_var: str, modules: List[str], config: Dict) -> str:
+    """Generate main application code with module instantiations."""
+    sleep_ms = config.get("global_settings", {}).get("monitor_sleep_ms", 1000)
+    headers = [
+        '#include "app_framework.hpp"',
+        '#include "libxr.hpp"',
+        "",
+        "// Module headers"
+    ] + [f'#include "{mod}.hpp"' for mod in modules]
+
+    body = [
+        f"template <typename HardwareContainer>",
+        f"static void XRobotMain(HardwareContainer &{hw_var}) {{",
+        f"  using namespace LibXR;",
+        f"  ApplicationManager appmgr;",
+        f"",
+        f"  // Auto-generated module instantiations",
+    ]
+
+    module_entries = config.get("modules", [])
+    if not isinstance(module_entries, list):
+        raise TypeError("[ERROR] 'modules' must be a list of module instances")
+
+    instance_count = {}
+
+    for entry in module_entries:
+        mod = entry.get("name")
+        if mod not in modules:
+            continue
+
+        args_dict = entry.get("constructor_args", {})
+        args_list = [_format_cpp_value(v) for _, v in args_dict.items()]
+
+        # Support for multiple instances of the same module
+        count = instance_count.get(mod, 0)
+        instance_name = f"{mod.lower()}{count}" if count > 0 else mod.lower()
+        instance_count[mod] = count + 1
+
+        instance_line = f"  {mod}<HardwareContainer> {instance_name}({hw_var}, appmgr"
+        if args_list:
+            instance_line += ", " + ", ".join(args_list)
+        instance_line += ");"
+        body.append(instance_line)
+
+    body += [
+        "",
+        f"  while (true) {{",
+        f"    appmgr.MonitorAll();",
+        f"    Thread::Sleep({sleep_ms});",
+        f"  }}",
+        f"}}"
+    ]
+
+    return "\n".join(headers + [""] + body)
+
+
+def auto_discover_modules(modules_dir: Path = Path("Modules")) -> List[str]:
+    """Discover available modules in directory."""
+    return [sub.name for sub in modules_dir.iterdir() if sub.is_dir() and (sub / f"{sub.name}.hpp").exists()]
+
+
+def main():
+    parser = argparse.ArgumentParser(description="XRobot code generation tool")
+    parser.add_argument("-o", "--output", required=True, help="Output CPP file path")
+    parser.add_argument("-m", "--modules", nargs="+", default=[], help="List of modules to include")
+    parser.add_argument("--hw", default="hw", help="Hardware container variable name")
+    parser.add_argument("-c", "--config", help="Configuration file path")
+
+    args = parser.parse_args()
+
+    # Module discovery
+    if not args.modules:
+        args.modules = auto_discover_modules()
+        print(f"Discovered modules: {', '.join(args.modules) or 'None'}")
+
+    # Configuration handling
+    config_data = {}
+    if args.config:
+        config_path = Path(args.config)
+        if config_path.exists():
+            config_data = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+        else:
+            config_data = extract_constructor_args(args.modules, Path("Modules"), config_path)
+
+    # Code generation
+    output_code = generate_xrobot_main_code(args.hw, args.modules, config_data)
+    Path(args.output).write_text(output_code, encoding="utf-8")
+    print(f"[SUCCESS] Generated entry file: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

xrobot-0.1.0/src/xrobot/InitModule.py

@@ -0,0 +1,79 @@
+import argparse
+import subprocess
+import yaml
+from pathlib import Path
+
+CONFIG_TEMPLATE = """# XRobot module configuration example
+modules:
+  - name: BlinkLED
+    repo: https://github.com/xrobot-org/BlinkLED
+    version: master  # optional: branch name or tag
+"""
+
+def execute_git_command(cmd: list[str], workdir: Path = None):
+    """Execute git commands with error handling."""
+    try:
+        subprocess.run(cmd, cwd=workdir, check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"[ERROR] Git command failed: {' '.join(cmd)}\n{str(e)}")
+
+def sync_module(name: str, repo: str, version: str, base_dir: Path):
+    """Clone or update a module repository."""
+    module_path = base_dir / name
+
+    if module_path.exists() and (module_path / ".git").exists():
+        print(f"[INFO] Updating module: {name}")
+        execute_git_command(["git", "pull"], workdir=module_path)
+        if version:
+            execute_git_command(["git", "checkout", version], workdir=module_path)
+    else:
+        print(f"[INFO] Cloning new module: {name}")
+        clone_cmd = ["git", "clone", "--recurse-submodules"]
+        if version:
+            clone_cmd += ["--branch", version]
+        clone_cmd += [repo, str(module_path)]
+        execute_git_command(clone_cmd)
+
+def load_configuration(config_path: Path) -> list[dict]:
+    """Load module configuration from YAML file."""
+    if not config_path.exists():
+        print(f"[WARN] Configuration file not found, creating template: {config_path}")
+        config_path.write_text(CONFIG_TEMPLATE, encoding="utf-8")
+        print("[INFO] Please edit the configuration file and rerun this script.")
+        return []
+
+    with config_path.open(encoding="utf-8") as f:
+        config_data = yaml.safe_load(f)
+    return config_data.get("modules", [])
+
+def main():
+    """Main entry point for module synchronization."""
+    parser = argparse.ArgumentParser(
+        description="XRobot module synchronization tool",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument("--config", "-c", default="modules.yaml",
+                        help="Path to module configuration file")
+    parser.add_argument("--directory", "-d", default="Modules",
+                        help="Output directory for module repositories")
+
+    args = parser.parse_args()
+    config_file = Path(args.config)
+    module_dir = Path(args.directory)
+    module_dir.mkdir(parents=True, exist_ok=True)
+
+    modules = load_configuration(config_file)
+    if not modules:
+        return
+
+    for module in modules:
+        if not all(key in module for key in ("name", "repo")):
+            print(f"[WARN] Skipping invalid module entry: {module}")
+            continue
+        version = module.get("version", None)
+        sync_module(module["name"], module["repo"], version, module_dir)
+
+    print("[SUCCESS] All modules processed")
+
+if __name__ == "__main__":
+    main()

xrobot-0.1.0/src/xrobot/ModuleCreator.py

@@ -0,0 +1,107 @@
+import argparse
+from pathlib import Path
+
+HEADER_TEMPLATE = """#pragma once
+
+// clang-format off
+/* === MODULE MANIFEST ===
+module_name: {module_name}
+module_description: {description}
+{constructor_line}{hardware_line}{repo_line}=== END MANIFEST === */
+// clang-format on
+
+#include "app_framework.hpp"
+
+template <typename HardwareContainer>
+class {module_name} : public LibXR::Application {{
+public:
+  {constructor_signature} {{
+    // Hardware initialization example:
+    // auto dev = hw.template Find<LibXR::GPIO>("led");
+  }}
+
+private:
+}};
+"""
+
+README_TEMPLATE = """# {module_name}
+
+{description}
+
+## Required Hardware
+{hardware}
+
+{repo_block}
+"""
+
+def create_module(module_name: str,
+                  description: str,
+                  required_hardware: list[str],
+                  repository: str,
+                  output_dir: Path = Path("Modules")):
+    """Create a new XRobot module with standard structure"""
+    mod_dir = output_dir / module_name
+    mod_dir.mkdir(parents=True, exist_ok=True)
+
+    # Template configuration for constructor arguments
+    constructor_line = "constructor_args:\n  - name: \"your_arg_name_here\"\n"
+    hardware_line = f"required_hardware: {' '.join(required_hardware)}\n" if required_hardware else ""
+    repo_line = f"repository: {repository}\n" if repository else ""
+
+    # Constructor signature template
+    constructor_signature = f"{module_name}(HardwareContainer &hw, LibXR::ApplicationManager &app)"
+
+    # Generate header file
+    hpp_code = HEADER_TEMPLATE.format(
+        module_name=module_name,
+        description=description,
+        constructor_line=constructor_line,
+        hardware_line=hardware_line,
+        repo_line=repo_line,
+        constructor_signature=constructor_signature
+    )
+
+    # Generate documentation
+    readme_code = README_TEMPLATE.format(
+        module_name=module_name,
+        description=description,
+        hardware=", ".join(required_hardware) or "None",
+        repo_block=f"## Repository\n{repository}" if repository else ""
+    )
+
+    (mod_dir / f"{module_name}.hpp").write_text(hpp_code, encoding="utf-8")
+    (mod_dir / "README.md").write_text(readme_code, encoding="utf-8")
+
+    # Generate build configuration
+    cmake_code = f"""# CMakeLists.txt for {module_name}
+
+# Add module to include path
+target_include_directories(xr PUBLIC ${{CMAKE_CURRENT_LIST_DIR}})
+
+# Auto-include source files
+file(GLOB MODULE_{module_name.upper()}_SRC
+    "${{CMAKE_CURRENT_LIST_DIR}}/*.cpp"
+    "${{CMAKE_CURRENT_LIST_DIR}}/*.c"
+)
+
+target_sources(xr PRIVATE ${{MODULE_{module_name.upper()}_SRC}})
+"""
+    (mod_dir / "CMakeLists.txt").write_text(cmake_code, encoding="utf-8")
+
+    print(f"[OK] Module {module_name} generated at {mod_dir}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Create a new XRobot module")
+    parser.add_argument("module_name", help="Module name (must match directory name)")
+    parser.add_argument("--desc", default="No description provided", help="Module description")
+    parser.add_argument("--hw", nargs="*", default=[], help="Required hardware interfaces (logical names)")
+    parser.add_argument("--repo", default="", help="GitHub repository URL (optional)")
+    parser.add_argument("--out", default="Modules", help="Output directory (default: Modules/)")
+
+    args = parser.parse_args()
+    create_module(args.module_name, args.desc, args.hw, args.repo, Path(args.out))
+
+
+if __name__ == "__main__":
+    main()

xrobot-0.1.0/src/xrobot/ModuleParser.py

@@ -0,0 +1,155 @@
+import re
+import yaml
+import argparse
+from pathlib import Path
+from typing import Optional, Dict, Union, OrderedDict
+
+
+def parse_constructor_args(text: str) -> OrderedDict:
+    """Parse constructor arguments with nested structure support.
+
+    Returns:
+        OrderedDict: Preserves argument order while maintaining nested structure awareness
+    """
+    args_dict = OrderedDict()
+    depth = 0
+    buffer = ""
+    key = None
+    i = 0
+
+    while i < len(text):
+        c = text[i]
+        if c in "{[(":
+            depth += 1
+            buffer += c
+        elif c in "}])":
+            depth -= 1
+            buffer += c
+        elif c == "," and depth == 0:
+            part = buffer.strip()
+            if "=" in part:
+                k, v = map(str.strip, part.split("=", 1))
+                args_dict[k] = v
+            elif key is not None:
+                args_dict[key] = part
+            buffer = ""
+            key = None
+        else:
+            buffer += c
+        i += 1
+
+    # Process final item
+    if buffer.strip():
+        part = buffer.strip()
+        if "=" in part:
+            k, v = map(str.strip, part.split("=", 1))
+            args_dict[k] = v
+        elif key is not None:
+            args_dict[key] = part
+
+    return args_dict
+
+
+def parse_manifest_from_header(header_path: Path) -> Optional[dict]:
+    """Extract and parse manifest block from module header file."""
+    try:
+        content = header_path.read_text(encoding="utf-8-sig")  # Handle BOM
+    except UnicodeDecodeError:
+        content = header_path.read_text(encoding="utf-8")
+
+    # Robust regex pattern allowing whitespace and line breaks
+    pattern = re.compile(
+        r"/\*\s*=== MODULE MANIFEST ===\s*[\r\n]+(.*?)[\r\n]+\s*=== END MANIFEST ===\s*\*/",
+        re.DOTALL
+    )
+    match = pattern.search(content)
+    if not match:
+        return None
+
+    manifest_block = match.group(1)
+    manifest_block = "\n".join(
+        [line.rstrip() for line in manifest_block.splitlines() if line.strip()]
+    )
+
+    try:
+        return yaml.safe_load(manifest_block)
+    except yaml.YAMLError:
+        return None
+
+
+def parse_module_folder(folder: Path) -> Optional[Dict[str, Union[str, list[str], dict]]]:
+    """Locate and parse manifest from matching header file in module directory."""
+    if not folder.is_dir():
+        return None
+
+    hpp_name = folder.name + ".hpp"
+    hpp_path = folder / hpp_name
+    if not hpp_path.exists():
+        return None
+
+    return parse_manifest_from_header(hpp_path)
+
+
+def parse_path(path: Path) -> Dict[str, Dict]:
+    """Main entry point: handles both module collections and individual modules."""
+    manifests = {}
+
+    if not path.exists():
+        return manifests
+
+    if path.is_dir():
+        # Check if path is a module directory
+        maybe_mod = path / (path.name + ".hpp")
+        if maybe_mod.exists():
+            if manifest := parse_module_folder(path):
+                manifests[manifest["module_name"]] = manifest
+        else:
+            # Process directory of modules
+            for sub in path.iterdir():
+                if sub.is_dir() and (manifest := parse_module_folder(sub)):
+                    manifests[manifest["module_name"]] = manifest
+    return manifests
+
+
+def print_manifest(name: str, manifest: dict):
+    """Display formatted module information."""
+    print(f"\n=== Module: {name} ===")
+
+    print(f"Description       : {manifest.get('module_description', '(no description)')}")
+    if repo := manifest.get("repository"):
+        print(f"Repository        : {repo}")
+
+    # Handle constructor arguments
+    args = manifest.get("constructor_args")
+    print("\nConstructor Args  : ", end="")
+    if isinstance(args, list) and all(isinstance(a, dict) for a in args):
+        for item in args:
+            for k, v in item.items():
+                print(f"\n  - {k:<18} = {v if v is not None else '(missing)'}")
+    else:
+        print("(invalid format)")
+
+    # Handle hardware requirements
+    hardware = manifest.get("required_hardware", [])
+    if isinstance(hardware, str):
+        hardware = [hardware]
+    print(f"\nRequired Hardware : {', '.join(hardware) if hardware else 'None'}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="XRobot module manifest parser")
+    parser.add_argument("--path", "-p", required=True,
+                        help="Path to module directory or module collection")
+    args = parser.parse_args()
+
+    manifests = parse_path(Path(args.path))
+    if not manifests:
+        print("[INFO] No module manifests found")
+        return
+
+    for name, manifest in manifests.items():
+        print_manifest(name, manifest)
+
+
+if __name__ == "__main__":
+    main()

xrobot-0.1.0/src/xrobot/XRobotSetup.py

@@ -0,0 +1,142 @@
+import subprocess
+import sys
+from pathlib import Path
+import yaml
+import argparse
+import urllib.request
+
+# Configuration paths
+MODULE_CONFIG = Path("./Modules/modules.yaml")
+MODULE_DIR = Path("./Modules/")
+OUTPUT_CPP = Path("./User/xrobot_main.hpp")
+CONSTRUCTOR_CONFIG: Path  # Type hint, no initial value
+
+# CLI tool names
+INIT_MODULE_CLI = "xrobot_init_mod"
+GENERATE_MAIN_CLI = "xrobot_gen_main"
+
+
+def run_subprocess(cmd: list[str]):
+    """Execute external command with logging"""
+    print(f"[EXEC] {' '.join(cmd)}")
+    subprocess.run(cmd, check=True)
+
+
+def ensure_module_config():
+    """Create default module configuration if missing"""
+    if not MODULE_CONFIG.exists():
+        MODULE_CONFIG.parent.mkdir(parents=True, exist_ok=True)
+        MODULE_CONFIG.write_text("""modules:
+  - name: BlinkLED
+    repo: https://github.com/xrobot-org/BlinkLED
+""", encoding="utf-8")
+        print(f"[INFO] Default config created: {MODULE_CONFIG}")
+        print("Please edit the file and rerun.")
+        sys.exit(0)
+
+def ensure_modules_cmakelists():
+    """Ensure a default CMakeLists.txt exists under Modules/, used to auto-include submodules"""
+    cmake_file = MODULE_DIR / "CMakeLists.txt"
+    if cmake_file.exists():
+        return  # Do not overwrite existing file
+
+    cmake_code = r'''# Automatically include all module CMakeLists.txt files under Modules/
+
+message(STATUS "[XRobot] Scanning module directory: Modules/")
+
+file(GLOB MODULE_DIRS RELATIVE ${CMAKE_CURRENT_LIST_DIR} ${CMAKE_CURRENT_LIST_DIR}/*)
+
+foreach(MOD ${MODULE_DIRS})
+    if(IS_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/${MOD}")
+        if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/${MOD}/CMakeLists.txt")
+            message(STATUS "[XRobot] Including module: ${MOD}")
+            include("${CMAKE_CURRENT_LIST_DIR}/${MOD}/CMakeLists.txt")
+        endif()
+    endif()
+endforeach()
+'''
+    cmake_file.write_text(cmake_code, encoding="utf-8")
+    print(f"[INFO] Generated default Modules/CMakeLists.txt at: {cmake_file}")
+
+
+def resolve_config_path(user_input: str | None) -> Path:
+    """Resolve config path from local path or URL"""
+    default_path = Path("./User/xrobot.yaml")
+
+    if not user_input:
+        return default_path
+
+    if user_input.startswith("http://") or user_input.startswith("https://"):
+        # Download remote YAML to local path
+        print(f"[INFO] Downloading config from URL: {user_input}")
+        default_path.parent.mkdir(parents=True, exist_ok=True)
+        urllib.request.urlretrieve(user_input, default_path)
+        print(f"[INFO] Config downloaded to: {default_path}")
+        return default_path
+
+    return Path(user_input)
+
+
+def extract_modules() -> list[str]:
+    """Retrieve module list from configuration"""
+    if not MODULE_CONFIG.exists():
+        return []
+
+    with MODULE_CONFIG.open(encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    return [m["name"] for m in data.get("modules", []) if "name" in m]
+
+
+def main():
+    """Main automation workflow"""
+    print("Starting XRobot auto-configuration")
+
+    parser = argparse.ArgumentParser(description="XRobot setup automation")
+    parser.add_argument("--config", help="Path or URL to constructor config YAML")
+    args = parser.parse_args()
+
+    # Step 0: Resolve config path
+    global CONSTRUCTOR_CONFIG
+    CONSTRUCTOR_CONFIG = resolve_config_path(args.config)
+
+    # Configuration validation
+    ensure_module_config()
+    modules = extract_modules()
+
+    if not modules:
+        print("[ERROR] No modules found in configuration")
+        sys.exit(1)
+
+    # Step 1: Repository management
+    run_subprocess([
+        INIT_MODULE_CLI,
+        "--config", str(MODULE_CONFIG),
+        "--dir", str(MODULE_DIR)
+    ])
+
+    ensure_modules_cmakelists()
+
+    # Step 2: Generate constructor config if missing
+    if not CONSTRUCTOR_CONFIG.exists():
+        run_subprocess([
+            GENERATE_MAIN_CLI,
+            "--output", str(OUTPUT_CPP),
+            "--config", str(CONSTRUCTOR_CONFIG)
+        ])
+        print(f"[INFO] Constructor config generated: {CONSTRUCTOR_CONFIG}")
+        print("Modify the configuration and rerun to apply changes")
+        sys.exit(0)
+
+    # Step 3: Code generation
+    run_subprocess([
+        GENERATE_MAIN_CLI,
+        "--output", str(OUTPUT_CPP),
+        "--config", str(CONSTRUCTOR_CONFIG)
+    ])
+
+    print(f"\nAll done! Main function generated at: {OUTPUT_CPP}")
+
+
+if __name__ == "__main__":
+    main()

xrobot-0.1.0/src/xrobot.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: xrobot
+Version: 0.1.0
+Summary: A Python package for parsing IOC files and generating C++ code.
+Author-email: Xiao <2592509183@qq.com>
+Maintainer-email: Xiao <2592509183@qq.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/xrobot-org
+Project-URL: Documentation, https://xrobot-org.github.io
+Project-URL: Repository, https://github.com/xrobot-org/XRobot
+Project-URL: Bug Tracker, https://github.com/xrobot-org/XRobot/issues
+Keywords: code generation,embedded systems,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argparse
+Requires-Dist: pyyaml
+Provides-Extra: gui
+Requires-Dist: PyQt5; extra == "gui"
+Provides-Extra: cli
+Requires-Dist: rich; extra == "cli"
+Requires-Dist: click; extra == "cli"
+Dynamic: license-file

xrobot-0.1.0/src/xrobot.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/xrobot/AddModule.py
+src/xrobot/GenerateMain.py
+src/xrobot/InitModule.py
+src/xrobot/ModuleCreator.py
+src/xrobot/ModuleParser.py
+src/xrobot/XRobotSetup.py
+src/xrobot/__init__.py
+src/xrobot.egg-info/PKG-INFO
+src/xrobot.egg-info/SOURCES.txt
+src/xrobot.egg-info/dependency_links.txt
+src/xrobot.egg-info/entry_points.txt
+src/xrobot.egg-info/requires.txt
+src/xrobot.egg-info/top_level.txt

xrobot-0.1.0/src/xrobot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xrobot-0.1.0/src/xrobot.egg-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+xrobot_add_mod = xrobot.AddModule:main
+xrobot_create_mod = xrobot.ModuleCreator:main
+xrobot_gen_main = xrobot.GenerateMain:main
+xrobot_init_mod = xrobot.InitModule:main
+xrobot_mod_parser = xrobot.ModuleParser:main
+xrobot_setup = xrobot.XRobotSetup:main

xrobot-0.1.0/src/xrobot.egg-info/requires.txt

@@ -0,0 +1,9 @@
+argparse
+pyyaml
+
+[cli]
+rich
+click
+
+[gui]
+PyQt5

xrobot-0.1.0/src/xrobot.egg-info/top_level.txt

@@ -0,0 +1 @@
+xrobot