alternative fetches of drivers and options (#107)

Author: hobu

pdal/drivers.py

@@ -4,6 +4,9 @@
 from typing import Callable, ClassVar, FrozenSet, Mapping, Optional, Sequence, Type
 
 from .pipeline import Filter, Reader, Stage, Writer
+from . import libpdalpython
+
+import shlex
 
 StreamableTypes: FrozenSet
 
@@ -59,6 +62,11 @@ def factory(self) -> Callable[..., Stage]:
 
 
 def inject_pdal_drivers() -> None:
+
+#     drivers = libpdalpython.getDrivers()
+#
+#     options = libpdalpython.getOptions()
+
     drivers = json.loads(
         subprocess.run(["pdal", "--drivers", "--showjson"], capture_output=True).stdout
     )
@@ -69,6 +77,19 @@ def inject_pdal_drivers() -> None:
             ).stdout
         )
     )
+
+    command = 'pdal --options all --showjson'
+
+    p = subprocess.run(shlex.split(command),
+                    encoding='utf-8',
+                    capture_output=True)
+    output, error = p.stdout, p.stderr
+    if p.returncode:
+        print (f'return code {p.returncode} error: "{error}"')
+        if error:
+            raise RuntimeError(f"Unable to run pdal --options with error '{error}'")
+
+    options = dict( json.loads( output ))
     streamable = []
     for d in drivers:
         name = d["name"]

pdal/libpdalpython.cpp

@@ -1,6 +1,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <pybind11/numpy.h>
+#include <iostream>
 
 #include <pdal/pdal_config.hpp>
 #include <pdal/StageFactory.hpp>
@@ -27,6 +28,72 @@ namespace pdal {
         );
     };
 
+   std::vector<py::dict> getDrivers() {
+        py::gil_scoped_acquire acquire;
+        std::vector<py::dict> drivers;
+
+        pdal::StageFactory f(false);
+        pdal::PluginManager<pdal::Stage>::loadAll();
+        pdal::StringList stages = pdal::PluginManager<pdal::Stage>::names();
+
+        pdal::StageExtensions& extensions = pdal::PluginManager<pdal::Stage>::extensions();
+        for (auto name : stages)
+        {
+            pdal::Stage *s = f.createStage(name);
+            std::string description = pdal::PluginManager<Stage>::description(name);
+            std::string link = pdal::PluginManager<Stage>::link(name);
+            std::vector<std::string> extension_names = extensions.extensions(name);
+
+            py::dict d(
+                "name"_a=name,
+                "description"_a=description,
+                "streamable"_a=s->pipelineStreamable(),
+                "extensions"_a=extension_names
+            );
+            f.destroyStage(s);
+            drivers.push_back(std::move(d));
+        }
+        return drivers;
+
+    };
+
+   std::vector<py::object> getOptions() {
+        py::gil_scoped_acquire acquire;
+        py::object json = py::module_::import("json");
+        std::vector<py::object> stageOptions;
+
+        pdal::StageFactory f;
+        pdal::PluginManager<pdal::Stage>::loadAll();
+        pdal::StringList stages = pdal::PluginManager<pdal::Stage>::names();
+
+        for (auto name : stages)
+        {
+            if ( name == "filters.info" ) continue;
+            pdal::Stage *s = f.createStage(name);
+            pdal::ProgramArgs args;
+            s->addAllArgs(args);
+            std::ostringstream ostr;
+            args.dump3(ostr);
+            py::str pystring(ostr.str());
+            pystring.attr("strip");
+
+            py::object j;
+
+            try {
+                j = json.attr("loads")(pystring);
+            } catch (py::error_already_set &e) {
+                std::cout << "failed:" << name << "'" << ostr.str() << "'" <<std::endl;
+                continue; // skip this one because we can't parse it
+            }
+
+            f.destroyStage(s);
+            py::list l = py::make_tuple( name, pystring);
+            stageOptions.push_back(std::move(l));
+       }
+        return stageOptions;
+
+    };
+
     std::vector<py::dict> getDimensions() {
         py::object np = py::module_::import("numpy");
         py::object dtype = np.attr("dtype");
@@ -172,6 +239,8 @@ namespace pdal {
         .def("_get_json", &Pipeline::getJson)
         .def("_del_executor", &Pipeline::delExecutor);
     m.def("getInfo", &getInfo);
+    m.def("getDrivers", &getDrivers);
+    m.def("getOptions", &getOptions);
     m.def("getDimensions", &getDimensions);
     m.def("infer_reader_driver", &StageFactory::inferReaderDriver);
     m.def("infer_writer_driver", &StageFactory::inferWriterDriver);

setup.py

@@ -16,7 +16,7 @@
     changes = fp.read()
 
 setup(
-    name="PDAL",
+    name="python-pdal",
     version=version,
     description="Point cloud data processing",
     license="BSD",