Make filename optional for readers/writers

Author: gsakkis

pdal/drivers.py

@@ -34,17 +34,12 @@ def __post_init__(self) -> None:
 
     @property
     def factory(self) -> Callable[..., Stage]:
-        factory: Callable[..., Stage]
-        if self.type is Reader:
-            factory = lambda filename, **kwargs: Reader(
-                filename, type=self.name, **kwargs
-            )
-        elif self.type is Writer:
-            factory = lambda filename=None, **kwargs: Writer(
-                filename, type=self.name, **kwargs
+        if self.options and self.options[0].name == "filename":
+            factory = lambda filename, **kwargs: self.type(
+                filename=filename, type=self.name, **kwargs
             )
         else:
-            factory = lambda **kwargs: Filter(type=self.name, **kwargs)
+            factory = lambda **kwargs: self.type(type=self.name, **kwargs)
         factory.__name__ = self.short_name
         factory.__qualname__ = f"{self.type.__name__}.{self.short_name}"
         factory.__doc__ = self.description

pdal/pipeline.py

@@ -2,7 +2,6 @@
 
 import glob
 import json
-from abc import ABC, abstractmethod
 from typing import Any, Container, Dict, Iterator, List, Optional, Sequence, Union, cast
 
 import numpy as np
@@ -89,31 +88,31 @@ def options(self) -> Dict[str, Any]:
         return dict(self._options)
 
     def pipeline(self, *arrays: np.ndarray) -> Pipeline:
-        return Pipeline((self,), arrays=arrays)
+        return Pipeline((self,), arrays)
 
     def __or__(self, other: Union[Stage, Pipeline]) -> Pipeline:
         return Pipeline((self, other))
 
 
-class InferableTypeStage(ABC, Stage):
-    @staticmethod
-    @abstractmethod
-    def infer_type(filename: str) -> str:
-        """Infer the driver type from the filename"""
+class InferableTypeStage(Stage):
+    def __init__(self, filename: Optional[str] = None, **options: Any):
+        if filename:
+            options["filename"] = filename
+        super().__init__(**options)
 
     @property
     def type(self) -> str:
         try:
             return super().type
         except KeyError:
-            return self.infer_type(self._options["filename"])
+            filename = self._options.get("filename")
+            return str(self._infer_type(filename) if filename else "")
 
+    _infer_type = staticmethod(lambda filename: "")
 
-class Reader(InferableTypeStage):
-    infer_type = staticmethod(libpdalpython.infer_reader_driver)
 
-    def __init__(self, filename: str, **options: Any):
-        super().__init__(filename=filename, **options)
+class Reader(InferableTypeStage):
+    _infer_type = staticmethod(libpdalpython.infer_reader_driver)
 
 
 class Filter(Stage):
@@ -122,10 +121,7 @@ def __init__(self, type: str, **options: Any):
 
 
 class Writer(InferableTypeStage):
-    infer_type = staticmethod(libpdalpython.infer_writer_driver)
-
-    def __init__(self, filename: Optional[str] = None, **options: Any):
-        super().__init__(filename=filename, **options)
+    _infer_type = staticmethod(libpdalpython.infer_writer_driver)
 
 
 def _parse_stages(text: str) -> Iterator[Stage]:

test/test_pipeline.py

@@ -188,6 +188,15 @@ def test_inputs(self):
         with pytest.raises(ValueError):
             (pdal.Reader("r") | f) | pipeline
 
+    def test_infer_stage_type(self):
+        """Can we infer stage type from the filename"""
+        assert pdal.Reader("foo.las").type == "readers.las"
+        assert pdal.Writer("foo.las").type == "writers.las"
+        assert pdal.Reader("foo.xxx").type == ""
+        assert pdal.Writer("foo.xxx").type == ""
+        assert pdal.Reader().type == ""
+        assert pdal.Writer().type == ""
+
     @pytest.mark.parametrize("filename", ["reproject.json", "reproject.py"])
     def test_logging(self, filename):
         """Can we fetch log output"""