faery 0.2.0__cp313-none-win_amd64.whl

faery/__init__.py

@@ -0,0 +1,61 @@
+import importlib.metadata
+import typing
+
+__version__ = importlib.metadata.version("faery")
+
+from .file_decoder import CsvProperties as CsvProperties
+from .events_filter import EVENTS_DTYPE as EVENTS_DTYPE
+from .events_input import events_stream_from_array as events_stream_from_array
+from .events_input import events_stream_from_file as events_stream_from_file
+from .events_input import events_stream_from_stdin as events_stream_from_stdin
+from .events_input import events_stream_from_udp as events_stream_from_udp
+from .events_stream import EventsStream as EventsStream
+from .events_stream import FiniteEventsStream as FiniteEventsStream
+from .events_stream import RegularEventsStream as RegularEventsStream
+from .events_stream import FiniteRegularEventsStream as FiniteRegularEventsStream
+from .file_type import FileType as FileType
+from .stream import TransposeAction as TransposeAction
+from .timestamp import Time as Time
+from .timestamp import parse_timestamp as parse_timestamp
+from .timestamp import timestamp_to_timecode as timestamp_to_timecode
+from .timestamp import timestamp_to_seconds as timestamp_to_seconds
+from . import cli as cli
+
+if typing.TYPE_CHECKING:
+    from .types import aedat  # type: ignore
+    from .types import csv  # type: ignore
+    from .types import dat  # type: ignore
+    from .types import event_stream  # type: ignore
+    from .types import evt  # type: ignore
+else:
+    from .extension import aedat
+    from .extension import csv
+    from .extension import dat
+    from .extension import event_stream
+    from .extension import evt
+
+__all__ = [
+    "__version__",
+    "CsvProperties",
+    "EVENTS_DTYPE",
+    "events_stream_from_array",
+    "events_stream_from_file",
+    "events_stream_from_stdin",
+    "events_stream_from_udp",
+    "EventsStream",
+    "FiniteEventsStream",
+    "RegularEventsStream",
+    "FiniteRegularEventsStream",
+    "FileType",
+    "TransposeAction",
+    "Time",
+    "parse_timestamp",
+    "timestamp_to_timecode",
+    "timestamp_to_seconds",
+    "aedat",
+    "csv",
+    "dat",
+    "event_stream",
+    "evt",
+    "cli",
+]

faery/__main__.py

@@ -0,0 +1,43 @@
+def main():
+
+    import argparse
+    import textwrap
+
+    import faery
+
+    parser = argparse.ArgumentParser(
+        prog="faery",
+        formatter_class=argparse.RawTextHelpFormatter,
+        description=textwrap.dedent(
+            rf"""
+                 __       __      _____
+                /  \     /  \    |  ___|_ _  ___ _ __ _   _
+                | ( \___/ ) |    | |_ / _` |/ _ \ '__| | | |
+                 \__/   \__/     |  _| (_| |  __/ |  | |_| |
+                   _\___/_       |_|  \__,_|\___|_|   \__, |
+                  (_/   \_)                           |___/
+
+            Faery converts Neuromorphic camera data (events) between formats.
+            It can also generate videos, spectrograms, and event rate curves.
+            """
+        ),
+    )
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"Faery {faery.__version__}"
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    faery.cli.convert.add_to_subparsers(subparsers)
+    faery.cli.render.add_to_subparsers(subparsers)
+    faery.cli.init.add_to_subparsers(subparsers)
+    faery.cli.run.add_to_subparsers(subparsers)
+    faery.cli.inline.add_to_subparsers(subparsers)
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+    else:
+        getattr(faery.cli, args.command).run(args)
+
+
+if __name__ == "__main__":
+    main()

faery/cli/__init__.py

@@ -0,0 +1,13 @@
+from . import convert as convert
+from . import init as init
+from . import inline as inline
+from . import render as render
+from . import run as run
+
+__all__ = [
+    "convert",
+    "init",
+    "inline",
+    "render",
+    "run",
+]

faery/cli/convert.py

@@ -0,0 +1,150 @@
+import argparse
+import sys
+
+import faery
+
+
+def add_to_subparsers(subparsers: argparse._SubParsersAction):
+    parser: argparse.ArgumentParser = subparsers.add_parser(
+        "convert", help="convert between event formats"
+    )
+    parser.add_argument(
+        "input", help='Path of the input file (use "stdin" for standard input)'
+    )
+    parser.add_argument(
+        "-f",
+        "--input-format",
+        choices=[
+            "aedat",
+            "csv",
+            "dat",
+            "es",
+            "evt",
+        ],
+        help="input format, required if the input is standard input",
+    )
+    parser.add_argument(
+        "-i",
+        "--track-id",
+        type=int,
+        help="set the track id for edat files (defaults to the first event stream)",
+    )
+    parser.add_argument(
+        "-j",
+        "--input-version",
+        choices=["dat1", "dat2", "evt2", "evt2.1", "evt3"],
+        help="set the version for evt (.raw) or dat files",
+    )
+    parser.add_argument(
+        "-x",
+        "--width",
+        type=int,
+        help="input width, required if the input format is csv",
+    )
+    parser.add_argument(
+        "-y",
+        "--height",
+        type=int,
+        help="input height, required if the input format is csv",
+    )
+    parser.add_argument(
+        "-t",
+        "--t0",
+        default=0,
+        help="set t0 for Event Stream files (defaults to 0)",
+    )
+    parser.add_argument(
+        "output", help='Path of the input file (use "stdout" for standard input)'
+    )
+    parser.add_argument(
+        "-g",
+        "--output-format",
+        choices=[
+            "aedat",
+            "csv",
+            "dat",
+            "es",
+            "evt",
+        ],
+        help="output format, required if the output is standard output",
+    )
+    parser.add_argument(
+        "-k",
+        "--output-version",
+        choices=["dat1", "dat2", "evt2", "evt2.1", "evt3"],
+        help="set the version for evt (.raw) or dat files",
+    )
+    parser.add_argument(
+        "-z",
+        "--zero-t0",
+        action="store_true",
+        help="offset the output's timestamps so that the first one is zero",
+    )
+    parser.add_argument(
+        "-p",
+        "--print-t0",
+        action="store_true",
+        help="print the output's original t0 (before offset if -z/--zero-t0 is set)",
+    )
+    parser.add_argument(
+        "-c",
+        "--compression-type",
+        choices=["lz4", "zstd"],
+        default="lz4",
+        help='set the compression algorithm for aedat files (defaults to "lz4")',
+    )
+    parser.add_argument(
+        "-d",
+        "--compression-level",
+        type=int,
+        default=1,
+        help="set the compression level for aedat files (defaults to 1)",
+    )
+
+
+def run(args: argparse.Namespace):
+    if (args.width is None) != (args.height is None):
+        sys.stderr.write(
+            "only one of width (-x/--width) and height (-y/--height) was provided (either both or neither should be provided)\n"
+        )
+        sys.exit(1)
+
+    # @TODO add support for udp
+    if args.input == "stdin":
+        assert args.input_format is not None
+        assert args.input_format == "csv"  # only supported stdin format at the moment
+        assert args.width is not None
+        assert args.height is not None
+        stream = faery.events_stream_from_stdin(dimensions=(args.width, args.height))
+    else:
+        if args.width is not None and args.height is not None:
+            stream = faery.events_stream_from_file(
+                path=args.input,
+                track_id=args.track_id,
+                dimensions_fallback=(args.width, args.height),
+                version_fallback=args.input_version,
+                t0=args.t0,
+                file_type=args.input_format,
+            )
+        else:
+            stream = faery.events_stream_from_file(
+                path=args.input,
+                track_id=args.track_id,
+                version_fallback=args.input_version,
+                t0=args.t0,
+                file_type=args.input_format,
+            )
+
+    if args.output == "stdout":
+        assert args.output_format == "csv"  # only supported stdout format at the moment
+        stream.to_stdout()
+    else:
+        t0 = stream.to_file(
+            path=args.output,
+            version=args.output_version,
+            zero_t0=args.zero_t0,
+            compression=(args.compression_type, args.compression_level),
+            file_type=args.output_format,
+        )
+        if args.print_t0:
+            print(t0)

faery/cli/init.py

@@ -0,0 +1,67 @@
+import argparse
+import os
+import pathlib
+
+
+def add_to_subparsers(subparsers: argparse._SubParsersAction):
+    parser: argparse.ArgumentParser = subparsers.add_parser(
+        "init", help="initialize a script to render multiple files"
+    )
+    parser.add_argument(
+        "-c",
+        "--configuration",
+        default=str(pathlib.Path(os.getcwd()) / "faery_configuration.py"),
+        help="path of the configuration file",
+    )
+    parser.add_argument(
+        "-s",
+        "--scan",
+        default=str(pathlib.Path(os.getcwd()) / "recordings"),
+        help="**/*.",
+    )
+    parser.add_argument(
+        "-f",
+        "--input-format",
+        choices=[
+            "aedat",
+            "csv",
+            "dat",
+            "es",
+            "evt",
+        ],
+        help="input format, required if the input is standard input",
+    )
+    parser.add_argument(
+        "-i",
+        "--track-id",
+        type=int,
+        help="set the track id for edat files (defaults to the first event stream)",
+    )
+    parser.add_argument(
+        "-j",
+        "--input-version",
+        choices=["dat1", "dat2", "evt2", "evt2.1", "evt3"],
+        help="set the version for evt (.raw) or dat files",
+    )
+    parser.add_argument(
+        "-x",
+        "--width",
+        type=int,
+        help="input width, required if the input format is csv",
+    )
+    parser.add_argument(
+        "-y",
+        "--height",
+        type=int,
+        help="input height, required if the input format is csv",
+    )
+    parser.add_argument(
+        "-t",
+        "--t0",
+        default=0,
+        help="set t0 for Event Stream files (defaults to 0)",
+    )
+
+
+def run(args: argparse.Namespace):
+    pass