dttlib 0.8.2__tar.gz → 0.9.1__tar.gz

{dttlib-0.8.2 → dttlib-0.9.1}/Cargo.lock

@@ -1408,7 +1408,7 @@ checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
 
 [[package]]
 name = "dtt_macros"
-version = "0.8.2"
+version = "0.9.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1417,7 +1417,7 @@ dependencies = [
 
 [[package]]
 name = "dttlib"
-version = "0.8.2"
+version = "0.9.1"
 dependencies = [
  "bindgen",
  "dtt_macros",
@@ -2969,7 +2969,7 @@ dependencies = [
 [[package]]
 name = "nds-cache-rs"
 version = "0.1.0"
-source = "git+https://git.ligo.org/cds/software/cr_tools/nds-cache-rs.git?tag=dev_18#7fc14bd2ad2cf4c027cb212ab171752c9cc5b46c"
+source = "git+https://git.ligo.org/cds/software/cr_tools/nds-cache-rs.git?tag=dev_20#d215ac31d0ae035a42f588e0a96677b40fa3bd1c"
 dependencies = [
  "arrakis",
  "bitcode",
@@ -3008,7 +3008,7 @@ dependencies = [
 
 [[package]]
 name = "nds_test"
-version = "0.8.2"
+version = "0.9.1"
 dependencies = [
  "dttlib",
  "eframe",
@@ -3572,7 +3572,7 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pipeline_macros"
-version = "0.8.2"
+version = "0.9.1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3581,7 +3581,7 @@ dependencies = [
 
 [[package]]
 name = "pipelines"
-version = "0.8.2"
+version = "0.9.1"
 dependencies = [
  "futures",
  "num-complex",
@@ -4770,7 +4770,7 @@ checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 [[package]]
 name = "ts-tree-rs"
 version = "0.1.0"
-source = "git+https://git.ligo.org/cds/software/cr_tools/ts-tree-rs.git?tag=dev_1#5d55d4d1fa6bbb8299fc68c98e64ce43f7539c61"
+source = "git+https://git.ligo.org/cds/software/cr_tools/ts-tree-rs.git?tag=dev_2#299c2191a8d81998c7496432860d5256258aaff8"
 dependencies = [
  "intrusive-collections",
  "itertools 0.13.0",
@@ -4861,7 +4861,7 @@ dependencies = [
 
 [[package]]
 name = "user_messages"
-version = "0.8.2"
+version = "0.9.1"
 dependencies = [
  "log",
  "pretty_env_logger",

{dttlib-0.8.2 → dttlib-0.9.1}/Cargo.toml

@@ -7,7 +7,7 @@ authors = ["Erik von Reis <erik.vonreis@ligo.org>"]
 edition = "2024"
 homepage = "https://git.ligo.org/cds/software/cr-tools/dtt_rust"
 repository = "https://git.ligo.org/cds/software/cr-tools/dtt_rust"
-version = "0.8.2"
+version = "0.9.1"
 
 [package]
 name = "dttlib"
@@ -38,7 +38,7 @@ required-features = ["python"]
 
 [workspace.dependencies]
 # python
-pyo3 = { version="0.24", features=["num-complex", "macros"]}
+pyo3 = { version="0.24", features=["num-complex", "macros", "multiple-pymethods"]}
 pyo3-stub-gen = { version="0.11"}
 numpy = {version="0.24"}
 
@@ -82,7 +82,7 @@ num-rational = {version = "0.4"}
 
 # ligo
 nds2_client_rs = { git="https://git.ligo.org/erik.vonreis/nds_client_rs.git", tag = "dev_0", optional = true }
-nds-cache-rs = { git = "https://git.ligo.org/cds/software/cr_tools/nds-cache-rs.git", tag = "dev_18"}
+nds-cache-rs = { git = "https://git.ligo.org/cds/software/cr_tools/nds-cache-rs.git", tag = "dev_20"}
 ligo_hires_gps_time = {workspace = true}
 
 # workspace

{dttlib-0.8.2 → dttlib-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dttlib
-Version: 0.8.2
+Version: 0.9.1
 License-File: COPYING
 License-File: COPYING-GPL-3
 Summary: Advanced LIGO core library for online and offline frequency-domain diagnostics tool.

dttlib-0.9.1/build.rs

@@ -0,0 +1,18 @@
+use std::env;
+use std::path::PathBuf;
+
+fn main() {
+    println!("cargo:rustc-link-lib=gds-sigp");
+    println!("cargo:rustc-link-lib=fftw3");
+
+    let bindings = bindgen::Builder::default()
+        .header("wrapper.h")
+        .generate()
+        .expect("Unable to generate bindings");
+
+    let out_path =
+        PathBuf::from(env::var("OUT_DIR").expect("Environment var OUT_DIR must be a path"));
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings");
+}

{dttlib-0.8.2 → dttlib-0.9.1}/dtt_macros/src/builder_lite.rs

@@ -4,9 +4,21 @@
 //! # Examples
 //!
 //! ```
+//! use dtt_macros::*;
+//!
+//! struct NeedsCustomFunc {
+//!     // this structure needs a special function
+//!     // for initialization
+//! }
+//!
+//! struct DontModify {
+//!     // this structure is created internally
+//!     // so should not be set during initialization
+//! }
+//!
 //! #[builder_lite]
 //! struct MyStruct {
-//!     field_a: int32,
+//!     field_a: i32,
 //!     field_b: String,
 //!     #[no_builder]
 //!     field_c: NeedsCustomFunc,
@@ -18,6 +30,18 @@
 //! expands to
 //!
 //! ```
+//! use dtt_macros::*;
+//!
+//! struct NeedsCustomFunc {
+//!     // this structure needs a special function
+//!     // for initialization
+//! }
+//!
+//! struct DontModify {
+//!     // this structure is created internally
+//!     // so should not be set during initialization
+//! }
+//!
 //! struct MyStruct {
 //!     field_a: i32,
 //!     field_b: String,

{dttlib-0.8.2 → dttlib-0.9.1}/dttlib.pyi

@@ -5,7 +5,7 @@ import builtins
 import typing
 from enum import Enum
 
-class AnalysisID:
+class AnalysisHeaderId:
     r"""
     This is the name of a result
     Can be of the simple form "SomeChannelName"
@@ -14,15 +14,33 @@ class AnalysisID:
     Structured to avoid unnecessary string parsing
     """
     @staticmethod
-    def from_channel(channel: Channel) -> AnalysisID: ...
+    def from_channel(channel: ChannelHeader) -> AnalysisHeaderId: ...
     def __new__(
-        cls, name: builtins.str, args: typing.Sequence[AnalysisID]
-    ) -> AnalysisID: ...
-    def first_channel(self) -> Channel:
+        cls, name: builtins.str, args: typing.Sequence[AnalysisHeaderId]
+    ) -> AnalysisHeaderId: ...
+    def first_channel(self) -> ChannelHeader:
         r"""
         get the first channel
         """
-    class Compound(AnalysisID):
+    def add_to_set_recursive(
+        self, set: builtins.set[AnalysisHeaderId]
+    ) -> builtins.set[AnalysisHeaderId]:
+        r"""
+        The set is pass-through ownership so that the function is usable from python
+
+        This function is needed to "flesh out" the collection of analyses request
+        by the user to include all intermediate analyses
+        """
+    def add_trend(self, trend: TrendType) -> AnalysisHeaderId: ...
+    def to_analysis_name_id(self) -> AnalysisNameId: ...
+    def get_channels(self) -> builtins.set[ChannelHeader]: ...
+    class Simple(AnalysisHeaderId):
+        __match_args__ = ("channel",)
+        @property
+        def channel(self) -> ChannelHeader: ...
+        def __new__(cls, channel: ChannelHeader) -> AnalysisHeaderId.Simple: ...
+
+    class Compound(AnalysisHeaderId):
         __match_args__ = (
             "name",
             "args",
@@ -30,16 +48,202 @@ class AnalysisID:
         @property
         def name(self) -> builtins.str: ...
         @property
-        def args(self) -> builtins.list[AnalysisID]: ...
+        def args(self) -> builtins.list[AnalysisHeaderId]: ...
         def __new__(
-            cls, name: builtins.str, args: typing.Sequence[AnalysisID]
-        ) -> AnalysisID.Compound: ...
+            cls, name: builtins.str, args: typing.Sequence[AnalysisHeaderId]
+        ) -> AnalysisHeaderId.Compound: ...
+
+class AnalysisId:
+    r"""
+    This is the name of a result
+    Can be of the simple form "SomeChannelName"
+    Or the compound form "Name(OtherID1, OtherID2, ...)"
 
-    class Simple(AnalysisID):
+    Structured to avoid unnecessary string parsing
+    """
+    @staticmethod
+    def from_channel(channel: Channel) -> AnalysisId: ...
+    def __new__(
+        cls, name: builtins.str, args: typing.Sequence[AnalysisId]
+    ) -> AnalysisId: ...
+    def first_channel(self) -> Channel:
+        r"""
+        get the first channel
+        """
+    def add_to_set_recursive(
+        self, set: builtins.set[AnalysisId]
+    ) -> builtins.set[AnalysisId]:
+        r"""
+        The set is pass-through ownership so that the function is usable from python
+
+        This function is needed to "flesh out" the collection of analyses request
+        by the user to include all intermediate analyses
+        """
+    def add_trend(self, trend: TrendType) -> AnalysisId: ...
+    def to_analysis_name_id(self) -> AnalysisNameId: ...
+    def get_channels(self) -> builtins.set[Channel]: ...
+    class Simple(AnalysisId):
         __match_args__ = ("channel",)
         @property
         def channel(self) -> Channel: ...
-        def __new__(cls, channel: Channel) -> AnalysisID.Simple: ...
+        def __new__(cls, channel: Channel) -> AnalysisId.Simple: ...
+
+    class Compound(AnalysisId):
+        __match_args__ = (
+            "name",
+            "args",
+        )
+        @property
+        def name(self) -> builtins.str: ...
+        @property
+        def args(self) -> builtins.list[AnalysisId]: ...
+        def __new__(
+            cls, name: builtins.str, args: typing.Sequence[AnalysisId]
+        ) -> AnalysisId.Compound: ...
+
+class AnalysisNameId:
+    r"""
+    This is the name of a result
+    Can be of the simple form "SomeChannelName"
+    Or the compound form "Name(OtherID1, OtherID2, ...)"
+
+    Structured to avoid unnecessary string parsing
+    """
+    @staticmethod
+    def from_channel(channel: ChannelName) -> AnalysisNameId: ...
+    def __new__(
+        cls, name: builtins.str, args: typing.Sequence[AnalysisNameId]
+    ) -> AnalysisNameId: ...
+    def first_channel(self) -> ChannelName:
+        r"""
+        get the first channel
+        """
+    def add_to_set_recursive(
+        self, set: builtins.set[AnalysisNameId]
+    ) -> builtins.set[AnalysisNameId]:
+        r"""
+        The set is pass-through ownership so that the function is usable from python
+
+        This function is needed to "flesh out" the collection of analyses request
+        by the user to include all intermediate analyses
+        """
+    def add_trend(self, trend: TrendType) -> AnalysisRequestId: ...
+    def to_analysis_name_id(self) -> AnalysisNameId: ...
+    def get_channels(self) -> builtins.set[ChannelName]: ...
+    class Simple(AnalysisNameId):
+        __match_args__ = ("channel",)
+        @property
+        def channel(self) -> ChannelName: ...
+        def __new__(cls, channel: ChannelName) -> AnalysisNameId.Simple: ...
+
+    class Compound(AnalysisNameId):
+        __match_args__ = (
+            "name",
+            "args",
+        )
+        @property
+        def name(self) -> builtins.str: ...
+        @property
+        def args(self) -> builtins.list[AnalysisNameId]: ...
+        def __new__(
+            cls, name: builtins.str, args: typing.Sequence[AnalysisNameId]
+        ) -> AnalysisNameId.Compound: ...
+
+class AnalysisRequestId:
+    r"""
+    This is the name of a result
+    Can be of the simple form "SomeChannelName"
+    Or the compound form "Name(OtherID1, OtherID2, ...)"
+
+    Structured to avoid unnecessary string parsing
+    """
+    @staticmethod
+    def from_channel(channel: ChannelId) -> AnalysisRequestId: ...
+    def __new__(
+        cls, name: builtins.str, args: typing.Sequence[AnalysisRequestId]
+    ) -> AnalysisRequestId: ...
+    def first_channel(self) -> ChannelId:
+        r"""
+        get the first channel
+        """
+    def add_to_set_recursive(
+        self, set: builtins.set[AnalysisRequestId]
+    ) -> builtins.set[AnalysisRequestId]:
+        r"""
+        The set is pass-through ownership so that the function is usable from python
+
+        This function is needed to "flesh out" the collection of analyses request
+        by the user to include all intermediate analyses
+        """
+    def add_trend(self, trend: TrendType) -> AnalysisRequestId: ...
+    def to_analysis_name_id(self) -> AnalysisNameId: ...
+    def get_channels(self) -> builtins.set[ChannelId]: ...
+    class Simple(AnalysisRequestId):
+        __match_args__ = ("channel",)
+        @property
+        def channel(self) -> ChannelId: ...
+        def __new__(cls, channel: ChannelId) -> AnalysisRequestId.Simple: ...
+
+    class Compound(AnalysisRequestId):
+        __match_args__ = (
+            "name",
+            "args",
+        )
+        @property
+        def name(self) -> builtins.str: ...
+        @property
+        def args(self) -> builtins.list[AnalysisRequestId]: ...
+        def __new__(
+            cls, name: builtins.str, args: typing.Sequence[AnalysisRequestId]
+        ) -> AnalysisRequestId.Compound: ...
+
+class AnalysisSettingsId:
+    r"""
+    This is the name of a result
+    Can be of the simple form "SomeChannelName"
+    Or the compound form "Name(OtherID1, OtherID2, ...)"
+
+    Structured to avoid unnecessary string parsing
+    """
+    @staticmethod
+    def from_channel(channel: ChannelSettings) -> AnalysisSettingsId: ...
+    def __new__(
+        cls, name: builtins.str, args: typing.Sequence[AnalysisSettingsId]
+    ) -> AnalysisSettingsId: ...
+    def first_channel(self) -> ChannelSettings:
+        r"""
+        get the first channel
+        """
+    def add_to_set_recursive(
+        self, set: builtins.set[AnalysisSettingsId]
+    ) -> builtins.set[AnalysisSettingsId]:
+        r"""
+        The set is pass-through ownership so that the function is usable from python
+
+        This function is needed to "flesh out" the collection of analyses request
+        by the user to include all intermediate analyses
+        """
+    def add_trend(self, trend: TrendType) -> AnalysisSettingsId: ...
+    def to_analysis_name_id(self) -> AnalysisNameId: ...
+    def get_channels(self) -> builtins.set[ChannelSettings]: ...
+    class Simple(AnalysisSettingsId):
+        __match_args__ = ("channel",)
+        @property
+        def channel(self) -> ChannelSettings: ...
+        def __new__(cls, channel: ChannelSettings) -> AnalysisSettingsId.Simple: ...
+
+    class Compound(AnalysisSettingsId):
+        __match_args__ = (
+            "name",
+            "args",
+        )
+        @property
+        def name(self) -> builtins.str: ...
+        @property
+        def args(self) -> builtins.list[AnalysisSettingsId]: ...
+        def __new__(
+            cls, name: builtins.str, args: typing.Sequence[AnalysisSettingsId]
+        ) -> AnalysisSettingsId.Compound: ...
 
 class Channel:
     @property
@@ -82,6 +286,19 @@ class Channel:
         cls, name: builtins.str, data_type: NDSDataType, period: PipDuration
     ) -> Channel: ...
 
+class ChannelHeader:
+    r"""
+    Used internally to map full name and trend info
+    this is the minimum needed information
+    to generate a request to the cache or other data source
+    """
+    @property
+    def name(self) -> builtins.str: ...
+    @property
+    def trend_type(self) -> TrendType: ...
+    @property
+    def trend_stat(self) -> TrendStat: ...
+
 class ChannelId:
     r"""
     Provides enough info to query a channel from an NDS server by name.
@@ -97,6 +314,14 @@ class ChannelId:
         One ChannelID will return into a channel for each.
         """
 
+class ChannelName:
+    r"""
+    Provides enough info to query a channel from an NDS server by name.
+    """
+    @property
+    def name(self) -> builtins.str: ...
+    def __new__(cls, name: builtins.str) -> ChannelName: ...
+
 class ChannelParams:
     @property
     def active(self) -> builtins.bool: ...
@@ -270,11 +495,11 @@ class FreqDomainArray:
     @property
     def data(self) -> typing.Any: ...
     @property
-    def id(self) -> AnalysisID: ...
+    def id(self) -> AnalysisId: ...
     @property
     def unit(self) -> Unit: ...
     def clone_metadata(
-        self, id: AnalysisID, unit: Unit, new_data: typing.Any
+        self, id: AnalysisId, unit: Unit, new_data: typing.Any
     ) -> FreqDomainArray:
         r"""
         Copy everything from another object except replace the data
@@ -644,18 +869,7 @@ class ScopeViewHandle:
         Update the span of a view.  This is a pythonic wrapper.  Rust code should call update_online() or update_fixed().
         """
     def close(self) -> None: ...
-    def get_result_store(self) -> builtins.dict[AnalysisID, typing.Any]: ...
-
-class SetMember:
-    class Channel(SetMember):
-        __match_args__ = ("_0",)
-        @property
-        def _0(self) -> Channel: ...
-        def __new__(cls, _0: Channel) -> SetMember.Channel: ...
-        def __len__(self) -> builtins.int: ...
-        def __getitem__(self, key: builtins.int) -> typing.Any: ...
-
-    ...
+    def get_result_store(self) -> builtins.dict[AnalysisId, typing.Any]: ...
 
 class SimpleUnit:
     r"""
@@ -1057,7 +1271,7 @@ class TimeDomainArray:
     @property
     def total_gap_size(self) -> builtins.int: ...
     @property
-    def id(self) -> AnalysisID: ...
+    def id(self) -> AnalysisId: ...
     @property
     def unit(self) -> Unit: ...
     @property
@@ -1077,6 +1291,13 @@ class TimeDomainArray:
         but the return value can be greater or equal to the length of the array
         and therefore out of bounds
         """
+    def timestamps(self) -> builtins.list[PipInstant]: ...
+    def delta_t_seconds(self, t0: PipInstant) -> builtins.list[builtins.float]:
+        r"""
+        Get the timestamps transformed into a delta time from some t0
+        return values in seconds as floating point
+        Useful for getting relative timestamps to a point of time on a graph
+        """
 
 class Timeline: ...
 
@@ -1110,6 +1331,10 @@ class ViewSet:
         for turning a simple list of channel names into a ViewSet with
         unresolved channel names
         """
+    @staticmethod
+    def from_analysis_request_ids(
+        request_ids: builtins.set[AnalysisRequestId],
+    ) -> ViewSet: ...
     def has_unresolved_channels(self) -> builtins.bool: ...
     def to_resolved_channel_names(self) -> builtins.list[builtins.str]:
         r"""

{dttlib-0.8.2 → dttlib-0.9.1}/pipelines/src/accumulator.rs

@@ -7,12 +7,12 @@
 //! This pipeline will only calculate one value at function call at a time.
 
 use crate::pipe::Pipe1;
-use crate::{PipeData, PipeResult, PipelineOutput, PipelineSubscriber};
+use crate::{PipeData, PipeResult, PipelineError, PipelineOutput, PipelineSubscriber};
 use futures::FutureExt;
 use futures::future::BoxFuture;
 use std::sync::Arc;
 use tokio::runtime::Handle;
-use user_messages::UserMsgProvider;
+use user_messages::{UserMsgProvider, panic_report};
 
 type AccumGenFn<I, T, U> =
     fn(Box<dyn UserMsgProvider>, Arc<I>, Option<Arc<T>>, n: f64) -> (Arc<T>, f64, PipeResult<U>);
@@ -37,8 +37,18 @@ fn accum_generate<I: PipeData, T: PipeData, U: PipeData>(
         let inp = input.clone();
         let accum_val = state.value.clone();
         let n = state.n;
-        let jh = Handle::current().spawn_blocking(move || g(rc, inp.value, accum_val, n));
-        let (value, new_n, output) = jh.await.unwrap();
+        let rc2 = rc.ump_clone();
+        let jh = Handle::current().spawn_blocking(move || g(rc2, inp.value, accum_val, n));
+        let (value, new_n, output) = match jh.await {
+            Ok(v) => v,
+            Err(e) => {
+                panic_report!(
+                    rc.user_message_handle(),
+                    "Error while running accumulator calculation thread: {}",
+                    e.to_string()
+                );
+            }
+        };
         state.n = new_n;
         state.value = Some(value.clone());
         output
@@ -52,7 +62,7 @@ impl<I: PipeData, T: PipeData, U: PipeData> Accumulator<I, T, U> {
         name: String,
         input: &PipelineSubscriber<I>,
         generate: AccumGenFn<I, T, U>,
-    ) -> PipelineSubscriber<U> {
+    ) -> Result<PipelineSubscriber<U>, PipelineError> {
         let p = Accumulator {
             n: 1.0, // start at 1.  The generator is responsible for incrementing if needed.
             generate_ptr: generate,