optocad_backscattermeter 0.0.0__py3-none-any.whl

optocad_backscattermeter/__init__.py

@@ -0,0 +1 @@
+"""Entry-point package."""

optocad_backscattermeter/cli.py

@@ -0,0 +1,143 @@
+"""Cli entry-point."""
+
+from argparse import ArgumentParser, Namespace, _SubParsersAction
+from pathlib import Path
+from sys import argv
+
+from astropy.units import Quantity
+
+from optocad_backscattermeter.utils import scan
+
+
+def build_parser() -> ArgumentParser:
+    """Build argument parser."""
+    parser = ArgumentParser(
+        prog="optocad_backscattermeter",
+        description="Run one or multiple OptoCad simulation.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    build_scan(subparsers)
+
+    return parser
+
+
+def build_scan(
+    subparsers: _SubParsersAction[ArgumentParser],
+) -> ArgumentParser:
+    """Build scan parser."""
+    scan = subparsers.add_parser(name="scan")
+    scan.add_argument(
+        "-n",
+        "--configuration-name",
+        type=str,
+        required=True,
+        help="name of the configuration",
+    )
+    scan.add_argument(
+        "-m",
+        "--motorized-mirror-angle",
+        type=str,
+        required=True,
+        nargs="+",
+        help=(
+            "angle offset of the motorized mirror from 45 deg. Can be "
+            "written with unit, default to deg. Can be a list of "
+            "value for a scan"
+        ),
+    )
+    scan.add_argument(
+        "-s",
+        "--sample-angle",
+        type=str,
+        required=True,
+        nargs="+",
+        help=(
+            "angle offset of the sample compared to the orthogonal."
+            "Can be written with unit, default to deg. Can be a list "
+            "of value for a scan"
+        ),
+    )
+    scan.add_argument(
+        "-p",
+        "--sample-position",
+        type=str,
+        required=True,
+        nargs="+",
+        help=(
+            "position of the sample on the suspended bench. This is "
+            "the distance between the start of the bench and the "
+            "sample. Can be written with unit, default to cm. Can be a "
+            "list of value for a scan"
+        ),
+    )
+    scan.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        required=False,
+        help="File to write the result to. If none, stdout",
+    )
+    scan.add_argument(
+        "-w",
+        "--overwrite",
+        action="store_true",
+        help=(
+            "Overwrite the file if it exists. Useless if output is not "
+            "specified"
+        ),
+    )
+
+    return scan
+
+
+def to_quantity(values: list[str], default_unit: str) -> Quantity:
+    """Parse quantity, allows float: add default unit in this case."""
+    result = []
+    for value in values:
+        try:
+            result.append(Quantity(float(value), unit=default_unit))
+        except ValueError:
+            result.append(Quantity(value))
+
+    return Quantity(result)
+
+
+def run_scan(namespace: Namespace) -> int:
+    """Run scan simulation."""
+
+    result = scan(
+        configuration_name=namespace.configuration_name,
+        motorized_mirror_angle=to_quantity(
+            namespace.motorized_mirror_angle, "deg"
+        ),
+        sample_angle=to_quantity(namespace.sample_angle, "deg"),
+        sample_position=to_quantity(namespace.sample_position, "cm"),
+    )
+
+    if namespace.output is None:
+        print(result)  # noqa: T201
+    else:
+        if namespace.output.exists() and not namespace.overwrite:
+            message = (
+                f"output file {namespace.output} already exists, use "
+                "--overwrite to replace it"
+            )
+            raise ValueError(message)
+
+        result.write(
+            namespace.output,
+            format="ascii.ecsv",
+            overwrite=namespace.overwrite,
+        )
+
+    return 0
+
+
+def main() -> int:
+    """Enter the main CLI entry-point."""
+
+    namespace = build_parser().parse_args(argv[1:])
+
+    if namespace.command == "scan":
+        return run_scan(namespace)
+    return 1

optocad_backscattermeter/configuration/1

@@ -0,0 +1,70 @@
+# BEAM
+b	x=36,	y=0,	w=350e-6,	ag=-180, z=0
+
+# BS1
+d	ac=srt,	x=17,	y=0,	rd=1.,	ag=135 # BS1 @ 1, 1, 1.2
+	+ t,	dm=0.2
+
+# MM
+d	ac=r,	x=17,	y=-6,	rd=1.,	ag={absolute_motorized_mirror_angle} # MM @ 1, 0, 1.2
+	+ d,	dm=0.2
+
+# L1
+d ac=t,	x=-0.5,	y=-6,	rd=1.,	ag=0,	f=50 # L1 @ 0, 1.5, 1.2
+	+ t,	dm=0.2
+
+# M4
+d	ac=r,	x=-3.5,	y=-6,	rd=1.,	ag=-217 # M4 @ 0, 1.5, 1.2
+	+ d,	dm=0.2
+
+# M5
+d	ac=r,	x=3.2,	y=-28.5,	rd=1.,	ag=-82.0 # M5 @ 0, -1.5, 1.2
+	+ d,	dm=0.2
+
+# L2
+#d	ac=t,	x=3,	y=-13.5,	rd=1.,	ag=90,	f=-10 # L3 @ 1.5, 0, 1.2
+#	+ t,	dm=0.2
+
+# L3
+d	ac=t,	x=2.961387143,	y=16.5,	rd=2.,	ag=90,	f=40 # L3 @ 2.5, 0, 1.2
+	+ t,	dm=0.2
+
+# start of the bench
+d	ac=t,	x=2.961387143,	y=22.5,	rd=2.,	ag=90, m=0 # start of the bench @ 2.5, 0, 1.2
+	+ t,	dm=0.2
+
+# M6
+d	ac=r,	x=17,	y=4.062426105,	rd=1.,	ag=45 # M6 @ 1.5, 0, 1.2
+	+ d,	dm=0.2
+
+# M7
+d	ac=r,	x=12.5,	y=0,	rd=1.,	ag=-135 # M7 @ -2.5, 0, 1.2
+	+ d,	dm=0.2
+
+# BS2
+d	ac={{srt}}2,	x=12.5, y=4,	rd=1.,	ag=45 # BS2 @ -3, 1, 1.2
+	+ t,	dm=0.2
+
+# BS3
+d	ac={{srt}}2,	x=-7.5,	y=4,	rd=1.,	ag=-45 # BS3 @ 0, 1.5, 1.2
+	+ t,	dm=0.2
+
+# M8
+d	ac=r,	x=12.5,	y=14,	rd=1.,	ag=45 # M8 @ 1.5, 0, 1.2
+	+ d,	dm=0.2
+
+# Camera
+d	ac=d,	x=-14.5,	y=4.124852211,	rd=1.,	ag=0 # C1 @ -1.5, 0, 1.2
+	+ d,	dm=0.2
+
+# PD1
+d	ac=d,	x=-20,	y=14,	rd=1.,	ag=0 # PD1 @ -2, 0, 1.2
+	+ d,	dm=0.2
+
+# PD2
+d	ac=d,	x=-7.312721683,	y=-8,	rd=1.,	ag=90 # PD2 @ -1, -1.5, 1.2
+	+ d,	dm=0.2
+
+# sample
+d	ac=r,	x=2.961387143,	y={absolute_sample_position},	rd=1.,	ag={absolute_sample_angle} # sample @ -1.5, 1, 1.2
+	+ d,	dm=0.2

optocad_backscattermeter/configuration.py

@@ -0,0 +1,76 @@
+"""Configuration class."""
+
+from dataclasses import dataclass
+from importlib.resources import files
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar
+
+if TYPE_CHECKING:
+    from astropy.units import Quantity
+
+START_OF_BENCH_Y_CM = 22.5
+MOTORIZED_MIRROR_ANGLE_INIT_DEG = -45
+SAMPLE_ANGLE_INIT_DEG = 90
+
+
+@dataclass
+class Configuration:
+    """Backscattermeter setup configuration."""
+
+    configuration_name: str
+    motorized_mirror_angle: Quantity
+    sample_angle: Quantity
+    sample_position: Quantity
+    configuration_version: ClassVar[str] = "1.0"
+
+    def __post_init__(self) -> None:
+        """Validate and normalize units."""
+        self.sample_angle = self.sample_angle.to("deg")
+        self.motorized_mirror_angle = self.motorized_mirror_angle.to(
+            "deg"
+        )
+        self.sample_position = self.sample_position.to("cm")
+
+    @property
+    def configuration_file(self) -> Path:
+        """Path to the current configuration file."""
+
+        return Path(
+            str(
+                files("optocad_backscattermeter")
+                / "configuration"
+                / self.configuration_name
+            )
+        )
+
+    def read_configuration_file(self) -> str:
+        """Read the configuration file."""
+
+        return self.configuration_file.read_text()
+
+    def format(self, configuration: str) -> str:
+        """Format the configuration."""
+
+        return configuration.format(
+            absolute_motorized_mirror_angle=(
+                MOTORIZED_MIRROR_ANGLE_INIT_DEG
+                + self.motorized_mirror_angle.to_value("deg")
+            ),
+            absolute_sample_position=START_OF_BENCH_Y_CM
+            + self.sample_position.to_value("cm"),
+            absolute_sample_angle=SAMPLE_ANGLE_INIT_DEG
+            + self.sample_angle.to_value("deg"),
+        )
+
+    def generate(self) -> str:
+        """Generate the .ocd file of this configuration."""
+
+        return self.format(self.read_configuration_file())
+
+    def serialize(self) -> dict[str, str]:
+        """Serialize this object to a dict."""
+
+        return {
+            "configuration version": self.configuration_version,
+            "configuration name": self.configuration_name,
+        }

optocad_backscattermeter/fortran/display.f95

@@ -0,0 +1,30 @@
+Program SAMPLE
+  use optocad
+  use rsplot
+
+  call oc_init(psize=(/450., 800./),unit='cm')
+
+  call oc_frame(-30., -40., 50., 100., scale=0.5)
+
+  call oc_set(rix = (/1.45/), &
+              lambda = 1.054e-6, &
+        print = 'rs act dx dy x1 x2 ang med lb')
+
+  call oc_input('', nib)
+
+  icb0=1
+  icb1=2
+  icb2=ps_color((/1., .6, .6/))
+  icb3=ps_color((/1., .8, .8/))
+
+  do ib=1,nib
+    call oc_trace(ib)
+    call oc_beam(3.0, fill=icb3)
+    call oc_beam(2.0, fill=icb2)
+    call oc_beam(1.0, fill=icb1)
+    call oc_beam(0.0, icb0, 5, .1, rns=2., rnc=2)
+  end do
+  call oc_surf
+
+  call oc_exit
+  end

optocad_backscattermeter/parser.py

@@ -0,0 +1,257 @@
+"""Parser class."""
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+
+from astropy.units import Unit
+
+FIELDS = [
+    "rs",
+    "s1",
+    "s2",
+    "cp",
+    "md",
+    "a",
+    "asoi",
+    "rd",
+    "ang",
+    "Ang",
+    "an1",
+    "an2",
+    "w0t",
+    "w0s",
+    "w1t",
+    "w1s",
+    "w2t",
+    "w2s",
+    "z0t",
+    "z0s",
+    "z1t",
+    "z1s",
+    "z2t",
+    "z2s",
+    "R1t",
+    "R1s",
+    "R2t",
+    "R2s",
+    "C1t",
+    "C1s",
+    "C2t",
+    "C2s",
+    "ipp",
+    "tpp",
+    "pw",
+    "pd",
+    "pa",
+    "tlt",
+    "tls",
+    "ph",
+    "gp1t",
+    "gp1s",
+    "gp2t",
+    "gp2s",
+    "Gp1",
+    "Gp2",
+    "Gp1t",
+    "Gp1s",
+    "Gp2t",
+    "Gp2s",
+    "x1",
+    "y1",
+    "x2",
+    "y2",
+    "dx",
+    "dy",
+    "sas",
+    "Sas",
+    "label",
+]  # from optocad documentation
+
+
+@dataclass
+class Column:
+    """A column of a table."""
+
+    name: str
+    unit: Unit | None
+    values: list[str | float | int | bool] = field(default_factory=list)
+
+
+@dataclass
+class Table:
+    """A table containing multiple columns."""
+
+    columns: list[Column]
+
+    def get(self, name: str) -> Column:
+        """Get a column from its name."""
+
+        for column in self.columns:
+            if column.name == name:
+                return column
+
+        message = f"Column {name} not found."
+        raise KeyError(message)
+
+
+@dataclass
+class Beam:
+    """Multiple tables."""
+
+    tables: list[Table] = field(default_factory=list)
+
+    def add_table(self, columns: list[Column]) -> None:
+        """Add a table to the beam."""
+
+        self.tables.append(Table(columns=columns))
+
+    def last(self) -> Table:
+        """Return the last table added."""
+
+        return self.tables[-1]
+
+
+@dataclass
+class ParserResult:
+    """Main parser result."""
+
+    beams: list[Beam] = field(default_factory=list)
+
+    def add_beam(self) -> None:
+        """Add a beam to the result."""
+
+        self.beams.append(Beam())
+
+    def last(self) -> Beam:
+        """Return the last beam added."""
+
+        return self.beams[-1]
+
+
+class ParserState(StrEnum):
+    """Parser possible state."""
+
+    BEFORE = "not in a beam, still waiting for it"
+    BEAM_START = "first line of a beam"
+    IN_TABLE = "inside a table"
+    BETWEEN_TABLE = "table closed maybe still in a beam"
+    AFTER = "not in a beam anymore"
+
+
+@dataclass
+class Parser:
+    """Parse OptoCad output."""
+
+    state: ParserState = ParserState.BEFORE
+    result: ParserResult = field(default_factory=ParserResult)
+
+    def parse(self, content: str) -> ParserResult:
+        """Parse the given content."""
+
+        self.state = ParserState.BEFORE
+        self.result = ParserResult()
+
+        for line in content.splitlines():
+            self.parse_line(line)
+
+        return self.result
+
+    def parse_line(  # noqa: C901
+        self,
+        line: str,
+    ) -> None:
+        """Parse a single line in function of the current state."""
+
+        if self.state is ParserState.BEFORE:
+            result = self.parse_beam(line)
+            if result:
+                self.state = ParserState.BEAM_START
+        elif self.state is ParserState.BEAM_START:
+            result = self.parse_header(line)
+            if not result:
+                message = f"Cannot parse line: {line!r}"
+                raise ValueError(message)
+            self.state = ParserState.IN_TABLE
+        elif self.state is ParserState.IN_TABLE:
+            result = self.parse_row(line)
+            if not result:
+                self.state = ParserState.BETWEEN_TABLE
+        elif self.state is ParserState.BETWEEN_TABLE:
+            result = self.parse_header(line)
+            if result:
+                self.state = ParserState.IN_TABLE
+            else:
+                result = self.parse_beam(line)
+                if result:
+                    self.state = ParserState.BEAM_START
+                else:
+                    self.state = ParserState.AFTER
+        elif self.state is ParserState.AFTER:
+            pass
+
+    def parse_beam(self, line: str) -> bool:
+        """Read a line announcing a new beam."""
+
+        result = line.startswith(
+            f"Beam # {len(self.result.beams) + 1}:"
+        )
+
+        if result:
+            self.result.add_beam()
+
+        return result
+
+    def parse_header(self, line: str) -> bool:
+        """Parse header line."""
+
+        columns_name = line.split()
+
+        if not columns_name:
+            return False
+
+        columns = []
+
+        for column in columns_name:
+            name, bracket, rest = column.partition("[")
+            unit = rest[:-1] if bracket and rest.endswith("]") else None
+
+            if bracket and unit is None:
+                message = f"Cannot parse {column} name."
+                raise ValueError(message)
+
+            if name not in FIELDS:
+                return False
+
+            if unit is not None:
+                unit = Unit(unit)
+
+            columns.append(Column(name=name, unit=unit))
+
+        self.result.last().add_table(columns=columns)
+
+        return True
+
+    def parse_row(self, line: str) -> bool:
+        """Parse table row."""
+
+        values = line.split(
+            maxsplit=len(self.result.last().last().columns) - 1
+        )
+
+        if not values:
+            return False
+
+        for column, value in zip(
+            self.result.last().last().columns, values, strict=True
+        ):
+            key = column.name
+            if key in ["rs", "s1", "s2", "cp"]:
+                column.values.append(int(value))
+            elif key == "md":
+                column.values.append(bool(int(value)))
+            elif key in ["label", "a", "asoi"]:
+                column.values.append(value)
+            else:
+                column.values.append(float(value))
+
+        return True

optocad_backscattermeter/utils.py

@@ -0,0 +1,167 @@
+"""Utils function."""
+
+from importlib.resources import files
+from itertools import product
+from pathlib import Path
+from shutil import which
+from subprocess import run
+from tempfile import NamedTemporaryFile
+
+from astropy.table import QTable, vstack
+from astropy.units import Quantity
+from numpy import atleast_1d, concatenate
+
+from optocad_backscattermeter.configuration import Configuration
+from optocad_backscattermeter.parser import Parser
+
+EXECUTABLE_NAME = "occr"
+
+
+def find_optocad() -> Path:
+    """Find the path to OptoCad from the $PATH."""
+
+    executable = which(EXECUTABLE_NAME)
+
+    if executable is None:
+        message = (
+            f"{EXECUTABLE_NAME!r} not found in $PATH. Did you install "
+            "OptoCad ?"
+        )
+        raise FileNotFoundError(message)
+
+    return Path(executable)
+
+
+def run_optocad(
+    ocd_file: Path,
+    fortran_display: Path,
+    executable: Path | None = None,
+) -> str:
+    """
+    Run OptoCad on the given .ocd file.
+
+    Parameters
+    ----------
+    ocd_file: Path
+        Path to the ocd file.
+    fortran_display: Path
+        Path to the necessary Fortran script used to load the ocd file.
+    executable: Path | None
+        Path to the executable. If None, find the path from the $PATH.
+
+    """
+
+    if executable is None:
+        executable = find_optocad()
+
+    completed = run(  # noqa: S603
+        [str(executable), str(fortran_display), str(ocd_file)],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+    return completed.stdout
+
+
+def to_table(configuration: Configuration, content: str) -> QTable:
+    """Parse OptoCad output and convert it into an astropy table."""
+
+    result = Parser().parse(content)
+
+    beams = []
+    for beam_number, beam in enumerate(result.beams):
+        header = {column.name for column in beam.tables[0].columns}
+
+        columns = {key: [] for key in sorted(header)}
+        columns["table number"] = []
+        # merge tables
+        for number, table in enumerate(beam.tables):
+            if header != {column.name for column in table.columns}:
+                message = "Different header on the same beam."
+                raise ValueError(message)
+
+            for column in table.columns:
+                if column.unit is not None:
+                    columns[column.name].append(
+                        Quantity(column.values, column.unit)
+                    )
+                else:
+                    columns[column.name].append(column.values)
+
+            columns["table number"].append(
+                [number] * len(table.columns[0].values)
+            )
+
+        for key, column in columns.items():
+            columns[key] = concatenate(column)  # type: ignore[ty:invalid-assignment]
+
+        table = QTable(data=columns)
+        table["beam number"] = beam_number
+        table["motorized mirror angle"] = (
+            configuration.motorized_mirror_angle
+        )
+        table["sample angle"] = configuration.sample_angle
+        table["sample position"] = configuration.sample_position
+
+        beams.append(table)
+
+    table = vstack(beams)
+    table.meta = configuration.serialize()
+
+    return table
+
+
+def scan(
+    configuration_name: str,
+    motorized_mirror_angle: Quantity,
+    sample_angle: Quantity,
+    sample_position: Quantity,
+) -> QTable:
+    """
+    Run one simulation per combination of the scanned values.
+
+    Each parameter is a scalar or a vector of quantities; several
+    vectors are combined as a cartesian product. Scalars are
+    treated as single-value vectors.
+    """
+
+    parameters = {
+        "motorized_mirror_angle": atleast_1d(motorized_mirror_angle),
+        "sample_angle": atleast_1d(sample_angle),
+        "sample_position": atleast_1d(sample_position),
+    }
+
+    tables = []
+    for combination in product(*parameters.values()):
+        arguments = dict(zip(parameters, combination, strict=True))
+        arguments["configuration_name"] = configuration_name
+
+        table = main(configuration=Configuration(**arguments))
+        tables.append(table)
+
+    return vstack(tables)
+
+
+def main(configuration: Configuration) -> QTable:
+    """Run the configuration and give back the result."""
+
+    with NamedTemporaryFile("w+") as file:
+        file.write(configuration.generate())
+        file.flush()
+
+        fortran_display = Path(
+            str(
+                files("optocad_backscattermeter")
+                / "fortran"
+                / "display.f95"
+            )
+        )
+
+        return to_table(
+            configuration,
+            run_optocad(
+                ocd_file=Path(file.name),
+                fortran_display=fortran_display,
+            ),
+        )

optocad_backscattermeter-0.0.0.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.5
+Name: optocad_backscattermeter
+Version: 0.0.0
+Summary: Tool to operate with the optocad model of the backscattermeter at LAPP
+Project-URL: Documentation, https://git.linarphy.net/linarphy/optocad_backscattermeter/wiki
+Project-URL: Homepage, https://git.linarphy.net/linarphy/optocad_backscattermeter
+Project-URL: Source, https://git.linarphy.net/linarphy/optocad_backscattermeter
+Project-URL: Issues, https://git.linarphy.net/linarphy/optocad_backscattermeter/issues
+Author-email: linarphy <linarphy@linarphy.net>
+License-Expression: GPL-3.0-or-later
+Keywords: backscattered light,virgo
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.14.7
+Requires-Dist: astropy>=8.0.2
+Description-Content-Type: text/markdown
+
+# Optocad backscattermeter
+
+This package is used to manage and work with optocad models of
+[the backscattermeter at LAPP](https://doi.org/10.48550/arXiv.2202.07370).
+
+## Getting started
+
+### Requirements
+
+- Python >= 3.14.7
+- rich >= 13.9.4 (console output)
+- optocad (you need to be in the LVK collaboration) with `occr` in your
+`$PATH`.
+
+### Installation
+
+To install this package in the current python environment, use
+
+```sh
+python -m pip install optocad_backscattermeter
+```

optocad_backscattermeter-0.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+optocad_backscattermeter/__init__.py,sha256=VUIQVWewj0apwFDp4PuWCAMlFOEYxpMmBmE8xak-pgU,27
+optocad_backscattermeter/cli.py,sha256=HIVLC8a7JBm1XOwdNDCuCLt3WB61EYFMUDrJk8V5ulk,3799
+optocad_backscattermeter/configuration.py,sha256=gKf_YCwC06bKu8_-vMBtpQ1c3PFrxysZgcmBb1U8HQw,2229
+optocad_backscattermeter/parser.py,sha256=Cr7CI0q7mVzJ2JNPgiSn3kNi7oZukQ9heb5uI_VZ_c8,5732
+optocad_backscattermeter/utils.py,sha256=Dyjp1hm3i-fW5yZuCDxDHqNRr-xaLtIZFHkB98votqk,4673
+optocad_backscattermeter/configuration/1,sha256=4CPF0XpF4ws6KOY6omqfSVkK1EhiNNEtdMdEGQ8NFQI,1505
+optocad_backscattermeter/fortran/display.f95,sha256=jEC1usoEBodmRbxoDAnt8Htq7EcbNZ3RQJL_fRf4sto,599
+optocad_backscattermeter-0.0.0.dist-info/METADATA,sha256=AkDcHlAzqAd75B8wCVvirGmvdqHzCkf-eiCFL9XGkoM,1421
+optocad_backscattermeter-0.0.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+optocad_backscattermeter-0.0.0.dist-info/entry_points.txt,sha256=R9EP0sIxR1pUaK54B-y450qeTaIC27b_OU_xxqiVq0Q,79
+optocad_backscattermeter-0.0.0.dist-info/RECORD,,

optocad_backscattermeter-0.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

optocad_backscattermeter-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+optocad_backscattermeter = optocad_backscattermeter.cli:main