mtlearn 0.1.1__tar.gz

mtlearn-0.1.1/.gitignore

@@ -0,0 +1,8 @@
+build/
+dist/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.scannerwork/
+.idea/
+.vscode/

mtlearn-0.1.1/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "external/MorphologicalAttributeFilters"]
+	path = external/MorphologicalAttributeFilters
+	url = https://github.com/wonderalexandre/MorphologicalAttributeFilters

mtlearn-0.1.1/CMakeLists.txt

@@ -0,0 +1,92 @@
+cmake_minimum_required(VERSION 3.20)
+
+# ---------------------------------------------------------------------------
+# Projeto principal do mtlearn
+# ---------------------------------------------------------------------------
+# Este arquivo prepara o ambiente CMake para compilar tanto a biblioteca C++
+# quanto os bindings Python e executáveis de teste. Ele pressupõe que o
+# repositório MorphologicalAttributeFilters esteja disponível como submódulo em
+# external/MorphologicalAttributeFilters.
+
+project(mtlearn LANGUAGES CXX)
+
+# Opções expostas para quem consome o projeto via CMake ou pyproject.toml.
+# - MTLEARN_BUILD_PYTHON : habilita o módulo pybind11 exportado para Python.
+# - MTLEARN_BUILD_TESTS  : compila os testes C++ e scripts auxiliares.
+# - MTLEARN_ENABLE_ASSERTS: controla o uso de asserts na biblioteca base.
+# - MTLEARN_ENABLE_EMBED : ativa testes que inicializam o interpretador Python
+#   embutido (útil apenas em ambientes com PyTorch completo).
+option(MTLEARN_BUILD_PYTHON "Build pybind11 bindings" ON)
+option(MTLEARN_BUILD_TESTS "Build C++ tests" OFF)
+option(MTLEARN_ENABLE_ASSERTS "Keep runtime asserts even in Release" OFF)
+option(MTLEARN_ENABLE_EMBED "Enable embedded Python interpreter tests" OFF)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Diretório extra para macros utilitárias do projeto.
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+# Respeita variáveis fornecidas via linha de comando/pyproject para localizar o
+# mesmo interpretador Python em todos os subprojetos.
+if(DEFINED PYTHON_EXECUTABLE AND NOT DEFINED Python3_EXECUTABLE)
+    set(Python3_EXECUTABLE "${PYTHON_EXECUTABLE}" CACHE FILEPATH "Python interpreter" FORCE)
+endif()
+if(DEFINED PYTHON_LIBRARY_DIR AND NOT DEFINED Python3_LIBRARY_DIR)
+    set(Python3_LIBRARY_DIR "${PYTHON_LIBRARY_DIR}" CACHE PATH "Python library directory" FORCE)
+endif()
+if(DEFINED Python3_EXECUTABLE AND NOT DEFINED Python3_ROOT_DIR)
+    get_filename_component(_mtlearn_py_bin "${Python3_EXECUTABLE}" DIRECTORY)
+    get_filename_component(_mtlearn_py_root "${_mtlearn_py_bin}" DIRECTORY)
+    set(Python3_ROOT_DIR "${_mtlearn_py_root}" CACHE PATH "Python root" FORCE)
+endif()
+
+set(MTLEARN_MMCFILTERS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external/MorphologicalAttributeFilters")
+# Garante que o submódulo do mmcfilters está disponível (obrigatório).
+if(NOT EXISTS "${MTLEARN_MMCFILTERS_DIR}/CMakeLists.txt")
+    message(FATAL_ERROR "Dependência mmcfilters não encontrada em ${MTLEARN_MMCFILTERS_DIR}. Adicione como submódulo ou ajuste o caminho.")
+endif()
+
+add_subdirectory(${MTLEARN_MMCFILTERS_DIR} mmcfilters)
+
+set(_mmc_target "")
+if(TARGET mmcfilters_lib)
+    set(_mmc_target mmcfilters_lib)
+elseif(TARGET mmcfilters::core)
+    set(_mmc_target mmcfilters::core)
+endif()
+
+if(NOT _mmc_target)
+    message(FATAL_ERROR "Não foi possível localizar o alvo principal do mmcfilters.")
+endif()
+
+# O mmcfilters oferece o alvo principal de algoritmos morfológicos. Ajustamos as
+# flags globais de asserts dependendo da opção fornecida ao projeto.
+if(MTLEARN_ENABLE_ASSERTS)
+    target_compile_definitions(${_mmc_target} PUBLIC MMCFILTERS_ENABLE_ASSERTS)
+    target_compile_options(${_mmc_target}
+        PUBLIC
+            $<$<CXX_COMPILER_ID:MSVC>:/UNDEBUG>
+            $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-UNDEBUG>
+    )
+else()
+    target_compile_definitions(${_mmc_target} PUBLIC NDEBUG)
+endif()
+
+# Diretório com as bibliotecas/aplicações C++ próprias do mtlearn.
+add_subdirectory(src)
+
+if(MTLEARN_BUILD_PYTHON)
+    # Inclui os bindings pybind11 que produzem o módulo _mtlearn e o pacote
+    # Python correspondente.
+    add_subdirectory(bindings)
+endif()
+
+if(MTLEARN_BUILD_TESTS)
+    enable_testing()
+    # Suite de testes C++ (smoke tests e interpretador python embutido).
+    add_subdirectory(tests)
+endif()

mtlearn-0.1.1/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.2
+Name: mtlearn
+Version: 0.1.1
+Summary: Morphological tree learning utilities built on top of mmcfilters
+Author-Email: Wonder Alexandre Luz Alves <worderalexandre@gmail.com>
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: C++
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.9
+Requires-Dist: mmcfilters>=0.1.20
+Requires-Dist: torch>=2.0
+Description-Content-Type: text/markdown
+
+# MTLearn
+
+Projeto C++/Python que reutiliza o núcleo `mmcfilters::core` para experimentos
+de aprendizado em árvores morfológicas.
+
+## Organização
+
+- `cmake/` — utilitários e módulos adicionais.
+- `external/` — dependências de código fonte (submódulos ou vendorizadas).
+- `src/` — código-fonte C++ da aplicação/biblioteca.
+- `bindings/` — módulo pybind11 com integração PyTorch específica do projeto.
+- `python/mtlearn/` — pacote Python puro.
+- `tests/` — testes C++ (compilados apenas se habilitados via CMake).
+
+## Dependência principal
+
+Adicionar `MorphologicalAttributeFilters` como submódulo:
+
+```bash
+git submodule add https://github.com/wonderalexandre/MorphologicalAttributeFilters external/MorphologicalAttributeFilters
+```
+
+## Build C++
+
+Instale previamente PyTorch (CPU ou CUDA) e exponha o caminho CMake, por exemplo:
+
+```bash
+python -c "import torch; print(torch.utils.cmake_prefix_path)"
+export Torch_DIR=$(python -c "import torch; print(torch.utils.cmake_prefix_path)")
+cmake -S . -B build -DMTLEARN_BUILD_TESTS=ON
+cmake --build build
+```
+
+- `MTLEARN_BUILD_TESTS` controla se a pasta `tests/` é adicionada ao build
+  (padrão `OFF`, recomendado para empacotamento via `pyproject.toml`).
+- `MTLEARN_ENABLE_EMBED` habilita testes que inicializam o interpretador
+  embutido; por padrão permanece `OFF` para evitar dependências extras do
+  PyTorch.
+- `MTLEARN_ENABLE_ASSERTS` mantém asserts do núcleo C++ ativos mesmo em build
+  Release (padrão `OFF`).
+
+Para rodar o teste com interpretador embutido:
+
+```bash
+cmake -S . -B build -DMTLEARN_BUILD_TESTS=ON -DMTLEARN_ENABLE_EMBED=ON \
+      -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") \
+      -DPYTHON_LIBRARY_DIR=$(python3 -c "import sysconfig; print(sysconfig.get_config_var('LIBDIR'))")
+cmake --build build
+ctest --test-dir build -R mtl_interpreter_test --output-on-failure
+```
+
+> Antes de habilitar `MTLEARN_ENABLE_EMBED`, verifique se o ambiente consegue
+> importar o PyTorch desejado (`python -c 'import torch'`). Caso contrário o
+> teste será ignorado (ou o próprio PyTorch precisará ser reinstalado com um
+> build compatível com o seu hardware).
+
+## Build Python (wheel)
+
+```bash
+pip install scikit-build-core pybind11 torch
+python -m build
+pip install -e .
+```
+
+Para uma instalação limpa via `pyproject.toml` não são necessários argumentos
+extras: os valores padrão já deixam asserts, testes e interpretador embutido
+desativados.

mtlearn-0.1.1/Pipfile

@@ -0,0 +1,11 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+
+[dev-packages]
+
+[requires]
+python_version = "3.13"

mtlearn-0.1.1/README.md

@@ -0,0 +1,67 @@
+# MTLearn
+
+Projeto C++/Python que reutiliza o núcleo `mmcfilters::core` para experimentos
+de aprendizado em árvores morfológicas.
+
+## Organização
+
+- `cmake/` — utilitários e módulos adicionais.
+- `external/` — dependências de código fonte (submódulos ou vendorizadas).
+- `src/` — código-fonte C++ da aplicação/biblioteca.
+- `bindings/` — módulo pybind11 com integração PyTorch específica do projeto.
+- `python/mtlearn/` — pacote Python puro.
+- `tests/` — testes C++ (compilados apenas se habilitados via CMake).
+
+## Dependência principal
+
+Adicionar `MorphologicalAttributeFilters` como submódulo:
+
+```bash
+git submodule add https://github.com/wonderalexandre/MorphologicalAttributeFilters external/MorphologicalAttributeFilters
+```
+
+## Build C++
+
+Instale previamente PyTorch (CPU ou CUDA) e exponha o caminho CMake, por exemplo:
+
+```bash
+python -c "import torch; print(torch.utils.cmake_prefix_path)"
+export Torch_DIR=$(python -c "import torch; print(torch.utils.cmake_prefix_path)")
+cmake -S . -B build -DMTLEARN_BUILD_TESTS=ON
+cmake --build build
+```
+
+- `MTLEARN_BUILD_TESTS` controla se a pasta `tests/` é adicionada ao build
+  (padrão `OFF`, recomendado para empacotamento via `pyproject.toml`).
+- `MTLEARN_ENABLE_EMBED` habilita testes que inicializam o interpretador
+  embutido; por padrão permanece `OFF` para evitar dependências extras do
+  PyTorch.
+- `MTLEARN_ENABLE_ASSERTS` mantém asserts do núcleo C++ ativos mesmo em build
+  Release (padrão `OFF`).
+
+Para rodar o teste com interpretador embutido:
+
+```bash
+cmake -S . -B build -DMTLEARN_BUILD_TESTS=ON -DMTLEARN_ENABLE_EMBED=ON \
+      -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") \
+      -DPYTHON_LIBRARY_DIR=$(python3 -c "import sysconfig; print(sysconfig.get_config_var('LIBDIR'))")
+cmake --build build
+ctest --test-dir build -R mtl_interpreter_test --output-on-failure
+```
+
+> Antes de habilitar `MTLEARN_ENABLE_EMBED`, verifique se o ambiente consegue
+> importar o PyTorch desejado (`python -c 'import torch'`). Caso contrário o
+> teste será ignorado (ou o próprio PyTorch precisará ser reinstalado com um
+> build compatível com o seu hardware).
+
+## Build Python (wheel)
+
+```bash
+pip install scikit-build-core pybind11 torch
+python -m build
+pip install -e .
+```
+
+Para uma instalação limpa via `pyproject.toml` não são necessários argumentos
+extras: os valores padrão já deixam asserts, testes e interpretador embutido
+desativados.

mtlearn-0.1.1/bindings/CMakeLists.txt

@@ -0,0 +1,224 @@
+# ---------------------------------------------------------------------------
+# Configuração do módulo pybind11 (_mtlearn) com integração ao PyTorch.
+# ---------------------------------------------------------------------------
+
+# Em alguns ambientes (ex.: pip editable) Torch_DIR pode apontar para um local
+# inválido. O trecho abaixo invalida a cache caso não exista o TorchConfig.
+if(Torch_DIR AND NOT EXISTS "${Torch_DIR}/TorchConfig.cmake")
+    unset(Torch_DIR CACHE)
+endif()
+
+# Preferimos uma instalação existente do pybind11, mas usamos FetchContent
+# caso não haja configuração previamente instalada.
+find_package(pybind11 CONFIG QUIET)
+
+if(NOT pybind11_FOUND)
+    include(FetchContent)
+    FetchContent_Declare(
+        pybind11
+        URL https://github.com/pybind/pybind11/archive/refs/tags/v2.13.1.tar.gz
+        DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+    )
+    FetchContent_MakeAvailable(pybind11)
+endif()
+
+find_package(Python3 COMPONENTS Interpreter QUIET)
+
+# Tentamos descobrir o Torch_DIR a partir do Python ativo, da site-packages do
+# usuário ou de variáveis de ambiente (útil para builds dentro do pip).
+if(NOT Torch_DIR)
+    if(Python3_Interpreter_FOUND)
+        execute_process(
+            COMMAND "${Python3_EXECUTABLE}" "-c" "import torch, sys; sys.stdout.write(torch.utils.cmake_prefix_path)"
+            OUTPUT_VARIABLE _torch_cmake_prefix
+            RESULT_VARIABLE _torch_query_result
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            ERROR_QUIET
+        )
+        if(_torch_query_result EQUAL 0 AND _torch_cmake_prefix)
+            set(Torch_DIR "${_torch_cmake_prefix}" CACHE PATH "Torch CMake config path" FORCE)
+        endif()
+    endif()
+endif()
+
+if((NOT Torch_DIR) AND Python3_Interpreter_FOUND)
+    execute_process(
+        COMMAND "${Python3_EXECUTABLE}" "-c" "import site, sys; paths = []\nfor p in site.getsitepackages():\n    if p not in paths:\n        paths.append(p)\nusr = site.getusersitepackages()\nif usr and usr not in paths:\n    paths.append(usr)\nsys.stdout.write('\n'.join(paths))"
+        OUTPUT_VARIABLE _torch_site_paths
+        RESULT_VARIABLE _torch_site_result
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+    if(_torch_site_result EQUAL 0 AND _torch_site_paths)
+        string(REPLACE "\r\n" ";" _torch_site_paths "${_torch_site_paths}")
+        string(REPLACE "\n" ";" _torch_site_paths "${_torch_site_paths}")
+        foreach(_site_path IN LISTS _torch_site_paths)
+            if(EXISTS "${_site_path}/torch/share/cmake/Torch/TorchConfig.cmake")
+                set(Torch_DIR "${_site_path}/torch/share/cmake/Torch" CACHE PATH "Torch CMake config path" FORCE)
+                break()
+            endif()
+        endforeach()
+    endif()
+endif()
+
+find_package(Torch REQUIRED)
+
+pybind11_add_module(_mtlearn module.cpp)
+
+target_link_libraries(_mtlearn PRIVATE mtlearn::core)
+
+# Começamos com os includes propagados pelo Torch e, em seguida, adicionamos
+# manualmente caminhos detectados em diferentes variantes de instalação
+# (conda/venv/libtorch standalone). Essa lista é compartilhada com os testes.
+set(_mtlearn_torch_includes ${TORCH_INCLUDE_DIRS})
+set(_mtlearn_torch_valid_includes "")
+foreach(_inc IN LISTS _mtlearn_torch_includes)
+    if(EXISTS "${_inc}")
+        list(APPEND _mtlearn_torch_valid_includes "${_inc}")
+        if(EXISTS "${_inc}/torch/csrc/api/include")
+            list(APPEND _mtlearn_torch_valid_includes "${_inc}/torch/csrc/api/include")
+        endif()
+        if(EXISTS "${_inc}/ATen")
+            list(APPEND _mtlearn_torch_valid_includes "${_inc}/ATen")
+        endif()
+    endif()
+endforeach()
+set(_mtlearn_torch_includes ${_mtlearn_torch_valid_includes})
+
+if(TORCH_INSTALL_PREFIX)
+    file(GLOB _mtlearn_torch_site_includes "${TORCH_INSTALL_PREFIX}/lib/python*/site-packages/torch/include")
+    file(GLOB _mtlearn_torch_pkg_includes "${TORCH_INSTALL_PREFIX}/pkgs/libtorch*/include")
+    foreach(_cand IN LISTS _mtlearn_torch_site_includes _mtlearn_torch_pkg_includes)
+        if(EXISTS "${_cand}" AND NOT "${_cand}" IN_LIST _mtlearn_torch_includes)
+            list(APPEND _mtlearn_torch_includes "${_cand}")
+        endif()
+        if(EXISTS "${_cand}/torch/csrc/api/include" AND NOT "${_cand}/torch/csrc/api/include" IN_LIST _mtlearn_torch_includes)
+            list(APPEND _mtlearn_torch_includes "${_cand}/torch/csrc/api/include")
+        endif()
+        if(EXISTS "${_cand}/ATen" AND NOT "${_cand}/ATen" IN_LIST _mtlearn_torch_includes)
+            list(APPEND _mtlearn_torch_includes "${_cand}/ATen")
+        endif()
+    endforeach()
+endif()
+
+if(DEFINED ENV{CONDA_PREFIX})
+    file(GLOB _mtlearn_conda_pkg_includes "$ENV{CONDA_PREFIX}/pkgs/libtorch*/include")
+    list(APPEND _mtlearn_torch_includes ${_mtlearn_conda_pkg_includes})
+    foreach(_cand IN LISTS _mtlearn_conda_pkg_includes)
+        if(EXISTS "${_cand}/torch/csrc/api/include")
+            list(APPEND _mtlearn_torch_includes "${_cand}/torch/csrc/api/include")
+        endif()
+        if(EXISTS "${_cand}/ATen")
+            list(APPEND _mtlearn_torch_includes "${_cand}/ATen")
+        endif()
+    endforeach()
+endif()
+
+if(Python3_Interpreter_FOUND)
+    execute_process(
+        COMMAND "${Python3_EXECUTABLE}" "-c" "import torch, sys; sys.stdout.write('\n'.join(torch.utils.cpp_extension.include_paths()))"
+        OUTPUT_VARIABLE _torch_extra_includes
+        RESULT_VARIABLE _torch_extra_result
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+    if(_torch_extra_result EQUAL 0 AND _torch_extra_includes)
+        string(REPLACE "\r\n" ";" _torch_extra_includes "${_torch_extra_includes}")
+        string(REPLACE "\n" ";" _torch_extra_includes "${_torch_extra_includes}")
+        foreach(_extra_inc IN LISTS _torch_extra_includes)
+            if(EXISTS "${_extra_inc}" AND NOT "${_extra_inc}" IN_LIST _mtlearn_torch_includes)
+                list(APPEND _mtlearn_torch_includes "${_extra_inc}")
+                if(EXISTS "${_extra_inc}/torch/csrc/api/include" AND NOT "${_extra_inc}/torch/csrc/api/include" IN_LIST _mtlearn_torch_includes)
+                    list(APPEND _mtlearn_torch_includes "${_extra_inc}/torch/csrc/api/include")
+                endif()
+            endif()
+        endforeach()
+    endif()
+endif()
+
+if(Python3_Interpreter_FOUND)
+    get_filename_component(_mtlearn_py_bindir "${Python3_EXECUTABLE}" DIRECTORY)
+    get_filename_component(_mtlearn_py_prefix "${_mtlearn_py_bindir}" DIRECTORY)
+    file(GLOB _mtlearn_py_pkg_includes "${_mtlearn_py_prefix}/pkgs/libtorch*/include")
+    list(APPEND _mtlearn_torch_includes ${_mtlearn_py_pkg_includes})
+    foreach(_cand IN LISTS _mtlearn_py_pkg_includes)
+        if(EXISTS "${_cand}/torch/csrc/api/include")
+            list(APPEND _mtlearn_torch_includes "${_cand}/torch/csrc/api/include")
+        endif()
+        if(EXISTS "${_cand}/ATen")
+            list(APPEND _mtlearn_torch_includes "${_cand}/ATen")
+        endif()
+    endforeach()
+endif()
+
+# Broaden search for Torch headers (extension.h, all.h) across typical prefixes.
+set(_mtlearn_torch_hint_paths)
+if(TORCH_INSTALL_PREFIX)
+    list(APPEND _mtlearn_torch_hint_paths "${TORCH_INSTALL_PREFIX}" "${TORCH_INSTALL_PREFIX}/include")
+    set(_mtlearn_prefix_step "${TORCH_INSTALL_PREFIX}")
+    foreach(_i RANGE 1 4)
+        get_filename_component(_mtlearn_prefix_step "${_mtlearn_prefix_step}" DIRECTORY)
+        if(_mtlearn_prefix_step)
+            list(APPEND _mtlearn_torch_hint_paths "${_mtlearn_prefix_step}")
+        endif()
+    endforeach()
+endif()
+if(DEFINED ENV{CONDA_PREFIX})
+    list(APPEND _mtlearn_torch_hint_paths "$ENV{CONDA_PREFIX}" "$ENV{CONDA_PREFIX}/pkgs")
+endif()
+if(Python3_SITEARCH)
+    list(APPEND _mtlearn_torch_hint_paths "${Python3_SITEARCH}")
+endif()
+if(Python3_SITELIB)
+    list(APPEND _mtlearn_torch_hint_paths "${Python3_SITELIB}")
+endif()
+list(APPEND _mtlearn_torch_hint_paths ${CMAKE_PREFIX_PATH})
+
+find_path(_mtlearn_torch_extension_dir
+    NAMES torch/extension.h
+    HINTS ${_mtlearn_torch_hint_paths}
+    PATH_SUFFIXES include torch/include)
+if(_mtlearn_torch_extension_dir)
+    list(APPEND _mtlearn_torch_includes "${_mtlearn_torch_extension_dir}")
+endif()
+
+find_path(_mtlearn_torch_all_dir
+    NAMES torch/all.h
+    HINTS ${_mtlearn_torch_hint_paths}
+    PATH_SUFFIXES include/torch/csrc/api/include torch/csrc/api/include)
+if(_mtlearn_torch_all_dir)
+    list(APPEND _mtlearn_torch_includes "${_mtlearn_torch_all_dir}")
+endif()
+
+find_path(_mtlearn_torch_aten_dir
+    NAMES ATen/ATen.h
+    HINTS ${_mtlearn_torch_hint_paths}
+    PATH_SUFFIXES include include/ATen)
+if(_mtlearn_torch_aten_dir)
+    list(APPEND _mtlearn_torch_includes "${_mtlearn_torch_aten_dir}")
+endif()
+
+# Deduplicate include list
+if(_mtlearn_torch_includes)
+    list(REMOVE_DUPLICATES _mtlearn_torch_includes)
+    set(MTLEARN_TORCH_INCLUDE_DIRS "${_mtlearn_torch_includes}" CACHE INTERNAL "Resolved Torch include directories for mtlearn")
+endif()
+
+# Diretórios de include do projeto (src/) mais os includes do Torch.
+target_include_directories(_mtlearn PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../src)
+if(_mtlearn_torch_includes)
+    target_include_directories(_mtlearn PRIVATE ${_mtlearn_torch_includes})
+endif()
+
+# Configurações padrão do módulo pybind11.
+set_target_properties(_mtlearn PROPERTIES OUTPUT_NAME "_mtlearn")
+set_property(TARGET _mtlearn PROPERTY CXX_STANDARD 20)
+set_property(TARGET _mtlearn PROPERTY CXX_STANDARD_REQUIRED ON)
+set_property(TARGET _mtlearn PROPERTY CXX_EXTENSIONS OFF)
+target_compile_definitions(_mtlearn PRIVATE TORCH_API_INCLUDE_EXTENSION_H)
+set_target_properties(_mtlearn PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+install(TARGETS _mtlearn
+        LIBRARY DESTINATION mtlearn
+        ARCHIVE DESTINATION mtlearn
+        RUNTIME DESTINATION mtlearn)

mtlearn-0.1.1/bindings/module.cpp

@@ -0,0 +1,37 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "mtlearn/core.hpp"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_mtlearn, m)
+{
+    m.doc() = "Python bindings for MTLearn built on top of mmcfilters";
+
+    py::class_<mtlearn::TreeStats>(m, "TreeStats")
+        .def(py::init<>())
+        .def_readwrite("num_nodes", &mtlearn::TreeStats::numNodes)
+        .def("describe", [](const mtlearn::TreeStats& stats) {
+            return mtlearn::describeTree(stats);
+        });
+
+    m.def(
+        "make_tree_stats",
+        [](int numNodes) {
+            return mtlearn::makeTreeStats(numNodes);
+        },
+        py::arg("num_nodes"),
+        "Create a simple TreeStats instance using a node count.");
+
+    m.def(
+        "make_tree_tensor",
+        [](int numNodes) {
+            auto stats = mtlearn::makeTreeStats(numNodes);
+            py::object torch = py::module::import("torch");
+            py::object tensor = torch.attr("arange")(numNodes, py::arg("dtype") = torch.attr("float32"));
+            return py::make_tuple(stats, tensor);
+        },
+        py::arg("num_nodes"),
+        "Return TreeStats and a torch tensor with a simple range (em Python)." );
+}

mtlearn-0.1.1/cmake/README.md

@@ -0,0 +1 @@
+Diretório reservado para módulos CMake auxiliares do projeto.

mtlearn-0.1.1/external/MorphologicalAttributeFilters/.git

@@ -0,0 +1 @@
+gitdir: ../../.git/modules/external/MorphologicalAttributeFilters

mtlearn-0.1.1/external/MorphologicalAttributeFilters/.gitignore

@@ -0,0 +1,17 @@
+build/* 
+mmcfilters.egg-info/*
+mmcfilters/__pycache__/*
+.eggs/*
+dist/*
+build_setup_py/*
+.DS_Store
+.virtual_documents/*
+Pipfile
+*.d
+*.o
+notebooks/.ipynb_checkpoints/*
+notebooks/.virtual_documents/*
+/tests/build
+/tests/build
+mmcfilters.cpython-312-darwin.so
+python/mmcfilters/_version.py

mtlearn-0.1.1/external/MorphologicalAttributeFilters/.vscode/c_cpp_properties.json

@@ -0,0 +1,24 @@
+{
+    "configurations": [
+        {
+            "name": "Mac",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "/opt/anaconda3/include/python3.9",
+                "/opt/anaconda3/include/python3.9/pybind11-global/pybind11",
+                "${workspaceFolder}/mmcfilters/include"
+            ],
+            "defines": [],
+            "macFrameworkPath": [
+                "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks",
+                "/System/Library/Frameworks",
+                "/Library/Frameworks"
+            ],
+            "compilerPath": "/usr/bin/clang++",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "macos-clang-x64"
+        }
+    ],
+    "version": 4
+}

mtlearn-0.1.1/external/MorphologicalAttributeFilters/.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+    "recommendations": [
+        "openai.openai-chatgpt-adhoc"
+    ]
+}