orchid-python-api 5.25.3__py3-none-any.whl → 5.25.4__py3-none-any.whl

orchid/dot_net_dom_access.py

@@ -1,241 +0,0 @@
-#  Copyright (c) 2017-2025 KAPPA
-#
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#
-#      http://www.apache.org/licenses/LICENSE-2.0 
-#
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-# This file is part of Orchid and related technologies.
-#
-
-import uuid
-from typing import Callable, Mapping, Union
-
-import deal
-import option
-import toolz.curried as toolz
-
-from orchid import (
-    unit_system as units,
-)
-
-# noinspection PyUnresolvedReferences
-from System import Guid
-
-# These methods in this module are based on the StackOverflow post:
-# https://stackoverflow.com/questions/36580931/python-property-factory-or-descriptor-class-for-wrapping-an-external-library
-#
-# Additionally, it resolves an issue I was experiencing with PyCharm: when I used `property` directly
-# in the class definition, PyCharm reported "Property 'xyz' could not be read. I think it might have been
-# than I needed to apply `curry` to the "getter method" I also defined in the class in order to pass the
-# attribute name at definition time (because `self` was only available at run-time).
-
-
-def get_dot_net_property_value(attribute_name, dom_object):
-    """
-    Return the value of the DOM property whose name corresponds to `attribute_name`.
-    :param attribute_name: The Python `attribute_name`.
-    :param dom_object: The DOM object whose property is sought.
-    :return: The value of the DOM property.
-    """
-    @toolz.curry
-    def python_name_to_words(python_name):
-        return python_name.split('_')
-
-    def capitalize_words(words):
-        return toolz.map(str.capitalize, words)
-
-    def words_to_dot_net_property_name(words):
-        return ''.join(words)
-
-    @toolz.curry
-    def get_value_from_dom(dom, property_name):
-        return getattr(dom, property_name)
-
-    # The function, `thread_last`, from `toolz.curried`, "splices" threads a value (the first argument)
-    # through each of the remaining functions as the *last* argument to each of these functions.
-    result = toolz.thread_last(attribute_name,
-                               python_name_to_words,
-                               capitalize_words,
-                               words_to_dot_net_property_name,
-                               get_value_from_dom(dom_object))
-    return result
-
-
-def dom_property(attribute_name, docstring):
-    """
-    Return the property of the DOM corresponding to `attribute_name` with doc string.
-    :param attribute_name: The name of the Python attribute.
-    :param docstring: The doc string to be attached to the resulting property.
-    :return: The Python property wrapping the value of the DOM property.
-    """
-    def getter(self):
-        result = get_dot_net_property_value(attribute_name, self._adaptee)
-        return result
-
-    # Ensure no setter for the DOM properties
-    return property(fget=getter, doc=docstring, fset=None)
-
-
-def map_reduce_dom_property(attribute_name, docstring, mapper, reducer, initial):
-    """
-    Return reduced collection property of the DOM corresponding to `attribute_name` with doc string, `docstring`.
-
-    Args:
-        attribute_name: The name of the transformed attribute.
-        docstring: The doc string to be attached to the resultant property.
-        mapper: A callable that transforms every item of the .NET DOM property.
-        reducer: A callable invoked to reduce the collection.
-        initial: The initial value of the reduction.
-
-    Returns:
-        The Python property wrapping the mapped and reduced DOM (collection) property items.
-    """
-    def getter(self):
-        result = toolz.pipe(get_dot_net_property_value(attribute_name, self._adaptee),
-                            lambda container: container.Items,
-                            toolz.map(mapper),
-                            lambda items: toolz.reduce(reducer, items, initial))
-        return result
-
-    # Ensure no setter for the DOM properties
-    return property(fget=getter, doc=docstring, fset=None)
-
-
-def transformed_dom_property(attribute_name, docstring, transformer):
-    """
-    Return the transformed property of the DOM corresponding to `attribute_name`.
-    :param attribute_name: The name of the Python attribute.
-    :param docstring: The doc string to be attached to the resulting property.
-    :param transformer: A callable to transform the value returned by the .NET DOM property.
-    :return: The Python property wrapping the transformed value of the DOM property.
-    """
-    def getter(self):
-        raw_result = get_dot_net_property_value(attribute_name, self._adaptee)
-        result = transformer(raw_result)
-        return result
-
-    # Ensure no setter for the DOM properties
-    return property(fget=getter, doc=docstring, fset=None)
-
-
-def transformed_dom_property_iterator(attribute_name, docstring, transformer):
-    """
-    Return transformed collection property of the DOM corresponding to `attribute_name` with doc string, `docstring`.
-    :param attribute_name: The name of the original attribute.
-    :param docstring: The doc string to be attached to the resultant property.
-    :param transformer: A callable invoked on each value in the list returned by the .NET DOM property.
-    :return: The Python property wrapping a Python iterator mapping values from the DOM property (collection) items.
-    """
-    def getter(self):
-        container = get_dot_net_property_value(attribute_name, self._adaptee)
-        result = toolz.map(transformer, container.Items)
-        return result
-
-    # Ensure no setter for the DOM properties
-    return property(fget=getter, doc=docstring, fset=None)
-
-
-def as_object_id(guid: Guid):
-    return uuid.UUID(str(guid))
-
-
-class DotNetAdapter:
-    @deal.pre(lambda _self, adaptee, _net_project_callable=None: adaptee is not None)
-    def __init__(self, adaptee):
-        """
-        Construct an instance adapting the .NET `adaptee`.
-
-        Args:
-            adaptee: The .NET DOM object to adapt.
-        """
-        self._adaptee = adaptee
-
-    @property
-    def dom_object(self):
-        """
-        (PROTECTED) Determine the DOM object being adapted.
-
-        This method is only intended to be used **INSIDE** the orchid package. It is **NOT** intended for
-        external use.
-
-        Returns:
-            The .NET DOM object being adapted.
-        """
-        return self._adaptee
-
-
-class IdentifiedDotNetAdapter(DotNetAdapter):
-    def __init__(self, adaptee, net_project_callable: Callable = None):
-        """
-        Construct an instance adapting `adaptee` with access to the .NET `IProject` provided by `net_project_callable`.
-        Args:
-            adaptee: The .NET DOM object to adapt.
-            net_project_callable: A callable returning the .NET `IProject` instance.
-        """
-        super().__init__(adaptee)
-        self._net_project_callable = net_project_callable
-
-    object_id = transformed_dom_property('object_id', 'The object ID of the adapted .NET DOM object.', as_object_id)
-
-    @property
-    def expect_project_units(self) -> Union[units.UsOilfield, units.Metric]:
-        """
-        (PROTECTED) Return the `UnitSystem` appropriate the .NET `IProject` of this instance.
-
-        Although by naming convention, this property is "public," the author intends it to be "protected";
-        that is, only called by classes derived from `IdentifiedDotNetAdapter` (and not necessarily all of those).
-
-        Returns:
-            A unit system - either `units.UsOilfield` or `units.Metric`.
-
-        Raises:
-            ValueError if the derived instances, for example, a `BaseTimeSeriesAdapter` is **not** associated with
-            an `IProject`.
-        """
-        return self._maybe_project_units.expect('Expected associated project')
-
-    @property
-    def _maybe_project_units(self) -> option.Option[Union[units.UsOilfield, units.Metric]]:
-        """
-        Return the `option.Option[UnitSystem]` appropriate the .NET `IProject` of this instance.
-
-        Although by naming convention, this property is "public," the author intends it to be "protected";
-        that is, only called by classes derived from `IdentifiedDotNetAdapter` (and not necessarily all of those).
-
-        Returns:
-            An `option.Option()` instance.
-
-            Some derived classes, such as 'NativeWellAdapter` and
-            `NativeDataFrame`, contain a `Project` property that returns the `IProject` of the .NET class.
-            For other derived classes, such as `BaseTimeSeriesAdapter`, the `IProject` cannot be determined. In the
-            former situation, an associated `IProject`, this method returns an
-            `option.Some[units.UsOilfield]` or an `option.Some[units.Metric]`. For the latter situation, no
-            associated `IProject`, this method returns `option.NONE`. The methods of the
-            [option.Option class](https://mat1g3r.github.io/option/option.html#module-option.option) allow
-            derived classes to process these two situations with less likelihood of an error.
-        """
-        return (option.Some(units.as_unit_system(self._net_project_callable().ProjectUnits))
-                if self._net_project_callable
-                else option.NONE)
-
-
-def dictionary_by_id(accumulator: Mapping[uuid.UUID, IdentifiedDotNetAdapter], mapped_object: IdentifiedDotNetAdapter):
-    """
-    Return a `Mapping` resulting from adding `mapped_object` to `accumulator`.
-
-    Args:
-        accumulator: The accumulated result.
-        mapped_object: The `IdentifiedDotNetAdapter` to be added to `accumulator`.
-
-    Returns:
-        The updated `Mapping`.
-    """
-    return toolz.assoc(accumulator, mapped_object.object_id, mapped_object)

orchid/measurement.py

@@ -1,35 +0,0 @@
-#
-# This file is part of Orchid and related technologies.
-#
-# Copyright (c) 2017-2025 KAPPA.  All Rights Reserved.
-#
-# LEGAL NOTICE:
-# Orchid contains trade secrets and otherwise confidential information
-# owned by KAPPA. Access to and use of this information is
-# strictly limited and controlled by the Company. This file may not be copied,
-# distributed, or otherwise disclosed outside of the Company's facilities 
-# except under appropriate precautions to maintain the confidentiality hereof, 
-# and may not be used in any way not expressly authorized by the Company.
-#
-
-
-import pint
-
-
-registry = pint.UnitRegistry()
-"""
-The single registry of all known `pint` units. See the Pint tutorial, 
-https://pint.readthedocs.io/en/stable/tutorial.html, for general information on the registry. Specifically, 
-see the section, https://pint.readthedocs.io/en/stable/tutorial.html#using-pint-in-your-projects, for the 
-"perils" of using multiple registry instances.
-"""
-
-# Expose general types for use by type annotations
-Quantity = registry.Quantity
-"""The type of a Pint measurement exposed for convenience."""
-Unit = registry.Unit
-"""The type of Pint units of measure."""
-
-# Register this instance of the registry as the application registry to support pickling and unpickling of Pint
-# Quantity and Unit instances.
-pint.set_application_registry(registry)

orchid/native_data_frame_adapter.py

@@ -1,247 +0,0 @@
-#
-# This file is part of Orchid and related technologies.
-#
-# Copyright (c) 2017-2025 KAPPA.  All Rights Reserved.
-#
-# LEGAL NOTICE:
-# Orchid contains trade secrets and otherwise confidential information
-# owned by KAPPA. Access to and use of this information is
-# strictly limited and controlled by the Company. This file may not be copied,
-# distributed, or otherwise disclosed outside of the Company's facilities 
-# except under appropriate precautions to maintain the confidentiality hereof, 
-# and may not be used in any way not expressly authorized by the Company.
-#
-
-import dataclasses
-import traceback
-import uuid
-from typing import Iterable
-
-import functools
-import option
-import pandas as pd
-import toolz.curried as toolz
-
-from orchid import (
-    base,
-    dot_net_dom_access as dna,
-    dot_net_disposable as dnd,
-    net_date_time as net_dt,
-)
-
-# noinspection PyUnresolvedReferences
-from System import DateTime, DateTimeOffset, DBNull, Guid, TimeSpan
-# noinspection PyUnresolvedReferences
-from System.Data import DataTable
-
-
-@dataclasses.dataclass
-class CellDto:
-    row: int
-    column: str
-    value: object
-
-
-@dataclasses.dataclass
-class DateTimeOffsetSentinelRange:
-    lower: DateTimeOffset
-    upper: DateTimeOffset
-
-    def __contains__(self, to_test: DateTimeOffset):
-        return self.lower <= to_test <= self.upper
-
-
-_MAX_SENTINEL_RANGE = DateTimeOffsetSentinelRange(DateTimeOffset.MaxValue.Subtract(TimeSpan(9999999)),
-                                                  DateTimeOffset.MaxValue)
-"""The range used to determine equality to the .NET `DateTimeOffset.MaxValue` sentinel."""
-
-
-class DataFrameAdapterDateTimeError(TypeError):
-    pass
-
-
-class DataFrameAdapterDateTimeOffsetMinValueError(ValueError):
-    def __init__(self, row_no, column_name):
-        super(DataFrameAdapterDateTimeOffsetMinValueError, self).__init__(
-            f'Unexpectedly found `DateTimeOffset.MinValue` at'
-            f' row, {row_no}, and column, "{column_name}", of Orchid `DataFrame`.')
-
-
-def transform_display_name(net_display_name):
-    maybe_display_name = option.maybe(net_display_name)
-    return maybe_display_name.expect('Unexpected value, `None`, for `display_name`.')
-
-
-class NativeDataFrameAdapterIdentified(dna.IdentifiedDotNetAdapter):
-    def __init__(self, net_data_frame):
-        super().__init__(net_data_frame, base.constantly(net_data_frame.Project))
-
-    name = dna.dom_property('name', 'The name of this data frame.')
-    display_name = dna.transformed_dom_property('display_name', 'The display name of this data frame.',
-                                                transform_display_name)
-
-    @property
-    def is_potentially_corrupt(self):
-        return self.name.endswith(' (Potentially Corrupted)')
-
-    def pandas_data_frame(self) -> pd.DataFrame:
-        """
-        Return the `pandas` `DataFrame` built from the native `IStaticDataFrame`.
-
-        Returns:
-            A `pandas` `DataFrame`.
-        """
-        return _table_to_data_frame(self.dom_object.DataTable)
-
-
-@functools.singledispatch
-def net_cell_value_to_pandas_cell_value(cell_value):
-    """
-    Convert a .NET `DataFrame` cell value to a `pandas.DataFrame` cell value.
-    Args:
-        cell_value: The cell value to convert.
-    """
-    raise NotImplementedError(f'Unexpected type, {type(cell_value)}, of value, {cell_value}')
-
-
-@net_cell_value_to_pandas_cell_value.register(int)
-@net_cell_value_to_pandas_cell_value.register(float)
-@net_cell_value_to_pandas_cell_value.register(str)
-def _(cell_value):
-    return cell_value
-
-
-@net_cell_value_to_pandas_cell_value.register(DateTime)
-def _(_cell_value):
-    raise TypeError('`System.DateTime` unexpected.')
-
-
-@net_cell_value_to_pandas_cell_value.register(DateTimeOffset)
-def _(cell_value):
-    def is_net_max_sentinel(cv):
-        # TODO: Loss of fractional second work-around
-        # Using equality "works-around" the acceptance test error for the Permian FDI Observations data frame. (The
-        # "Timestamp" field is not **actually** `DateTimeOffset.MaxValue` but `DateTimeOffset.MaxValue` minus 1 second.)
-        return cv in _MAX_SENTINEL_RANGE
-
-    if is_net_max_sentinel(cell_value):
-        return pd.NaT
-
-    if cell_value == DateTimeOffset.MinValue:
-        raise ValueError('`DateTimeOffset.MinValue` unexpected.')
-
-    return net_dt.as_date_time(cell_value)
-
-
-@net_cell_value_to_pandas_cell_value.register(DBNull)
-def _(_cell_value):
-    return None
-
-
-@net_cell_value_to_pandas_cell_value.register(Guid)
-def _(_cell_value):
-    return uuid.UUID(_cell_value.ToString())
-
-
-@net_cell_value_to_pandas_cell_value.register(TimeSpan)
-def _(cell_value):
-    if cell_value == TimeSpan.MaxValue or cell_value == TimeSpan.MinValue:
-        return pd.NaT
-
-    # TODO: TimeSpan 3 Mdays calculation work-around
-    # The Orchid code to create the `ObservationSetDataFrame` calculates a `TimeSpan` from the "Pick Time"
-    # and the stage part start time; however, one item in the .NET `DataFrame` has the corresponding
-    # "Pick Time" of `DateTimeOffset.MaxValue`. Unfortunately, the calculation simply subtracts which results
-    # in a very large (<~ 3 million days) but valid value. The work-around I chose to implement is to
-    # transform these kinds of values into `pd.NaT`.
-    if cell_value.TotalDays > 36525:  # ~ 100 years
-        return pd.NaT
-
-    return net_dt.as_duration(cell_value)
-
-
-def _table_to_data_frame(data_table: DataTable):
-    """
-    Converts a .NET `DataTable` to a `pandas` `DataFrame`.
-
-    Args:
-        data_table: The .NET `DataTable` to convert.
-
-    Returns:
-        The `pandas` `DataFrame` converted from the .NET `DataTable`.
-    """
-    result = toolz.pipe(data_table,
-                        _read_data_table,
-                        toolz.map(toolz.keymap(lambda e: e[1])),
-                        list,
-                        lambda rs: pd.DataFrame(data=rs),
-                        )
-    return result
-
-
-def _read_data_table(data_table: DataTable) -> Iterable[dict]:
-    """
-    Read each row of the .NET `DataTable` into an `Iterable` of  `dicts`.
-
-    Args:
-        data_table: The .NET `DataTable` to read.
-
-    Returns:
-        Yields a
-    """
-    # Adapted from code at
-    # https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/dataset-datatable-dataview/creating-a-datareader
-    # retrieved on 18-Apr-2021.
-    with dnd.disposable(data_table.CreateDataReader()) as reader:
-        while True:
-            if reader.HasRows:
-                has_row = reader.Read()
-                while has_row:
-                    yield _table_row_to_dict(reader)
-                    has_row = reader.Read()
-            else:
-                return
-            if not reader.NextResult():
-                break
-
-
-def _table_row_to_dict(reader):
-    @toolz.curry
-    def get_value(dt_reader, cell_location):
-        _, column_name = cell_location
-        return cell_location, dt_reader[column_name]
-
-    def add_to_dict(so_far, to_accumulate):
-        column_name, cell_value = to_accumulate
-        return toolz.assoc(so_far, column_name, cell_value)
-
-    def to_dict(pairs):
-        dict_result = toolz.reduce(add_to_dict, pairs, {})
-        return dict_result
-
-    def net_value_to_python_value(cell_location_value_pair):
-        (column_no, column_name), value = cell_location_value_pair
-        try:
-            converted = dataclasses.replace(CellDto(column_no, column_name, value),
-                                            value=net_cell_value_to_pandas_cell_value(value))
-            return (converted.row, converted.column), converted.value
-        except ValueError as ve:
-            if 'DateTimeOffset.MinValue' in str(ve):
-                raise DataFrameAdapterDateTimeOffsetMinValueError(column_no, column_name)
-            else:
-                raise Exception(f"Cannot read value from dot net data table column {column_no} named {column_name}, value {value}, {traceback.format_exc()}")
-        except TypeError as te:
-            if 'System.DateTime' in str(te):
-                raise DataFrameAdapterDateTimeError(value.GetType())
-            else:
-                raise Exception(f"Cannot read value from dot net data table column {column_no} named {column_name}, value {value}, {traceback.format_exc()}")
-
-    result = toolz.pipe(
-        reader.FieldCount,
-        range,
-        toolz.map(lambda column_no: (column_no, reader.GetName(column_no))),
-        toolz.map(get_value(reader)),
-        to_dict,
-        toolz.itemmap(net_value_to_python_value),
-    )
-    return result

orchid/native_fiber_data.py

@@ -1,73 +0,0 @@
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from Orchid.FractureDiagnostics.FiberDataSet import IFiberDataSet
-import orchid.base
-from orchid import (
-    dom_project_object as dpo,
-    native_fiber_data_set_info as info
-)
-from .utils import convert_dotnet_datetime_to_python_datetime
-from typing import List, Optional
-from datetime import datetime
-import pandas as pd
-
-INT32_MAX = 2147483647
-
-
-class NativeFiberData(dpo.DomProjectObject):
-    """Adapts a native IFiberDataSet to python."""
-
-    def __init__(self, net_fiber_data_set: IFiberDataSet):
-        """
-        Constructs an instance adapting a .NET IFiberDataSet.
-        Args:
-            net_fiber_data_set: The .NET fiber data set to be adapted.
-        """
-        super().__init__(net_fiber_data_set, orchid.base.constantly(net_fiber_data_set.Project))
-
-    @property
-    def file_path(self) -> str:
-        return self.dom_object.FilePath
-
-    @property
-    def depth_unit(self) -> str:
-        return self.dom_object.DepthUnit
-
-    @property
-    def timezone_info(self) -> str:
-        return self.dom_object.TimeZoneInfo
-
-    @property
-    def times_data_set(self) -> str:
-        return self.dom_object.TimesDataSet
-
-    @property
-    def data_sets_info(self) -> List[info.NativeFiberDataSetInfo]:
-        return [info.NativeFiberDataSetInfo(x) for x in self.dom_object.FiberDataSets]
-
-    def get_data_set(self, data_set_name: Optional[str] = None):
-        try:
-            data_set_info = next(x for x in self.dom_object.FiberDataSets if x.name == data_set_name) if data_set_name is not None else self.dom_object.FiberDataSets[0]
-        except StopIteration:
-            raise ValueError("No Data Set with this name in this fiber data object")
-        data = self.dom_object.GetDataSet(data_set_info)
-        data_list = [[data[i, j] for j in range(data.GetLength(1))] for i in range(data.GetLength(0))]
-        return pd.DataFrame(data_list)
-
-    def get_data_table(self, start_index: int = 0, end_index: int = INT32_MAX):
-        if end_index == INT32_MAX:
-            print("We strongly recommend that you avoid loading the entire data table and instead work with chunks, "
-                  "specifying the start and end indexes. You can also use the get_data_set method, which is faster.")
-        print("Retrieving the data table... This may take a few minutes")
-        data_table = self.dom_object.GetDataTable(self.dom_object.DepthUnit, start_index, end_index)
-        data_dict = {column: [row[column] for row in data_table.Rows] for column in data_table.Columns}
-        df = pd.DataFrame(data_dict)
-        print("Data table Retrieved")
-        return df
-
-    @property
-    def dates(self) -> List[datetime]:
-        return [convert_dotnet_datetime_to_python_datetime(x.ToString()) for x in self.dom_object.Times]
-
-    @property
-    def depths(self) -> List[float]:
-        return [x.Value for x in self.dom_object.Depths]

orchid/native_fiber_data_set_info.py

@@ -1,28 +0,0 @@
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from Orchid.FractureDiagnostics.FiberDataSet import IFiberDataSetInfo
-import orchid.base
-from orchid import (
-    dot_net_dom_access as dna,
-    dom_project_object as dpo,
-    dot_net_disposable as dnd,
-    net_date_time as ndt,
-)
-import json
-
-
-class NativeFiberDataSetInfo(dpo.DomProjectObject):
-    """Adapts a native IFiberDataSet to python."""
-
-    def __init__(self, net_fiber_data_set_info: IFiberDataSetInfo):
-        """
-        Constructs an instance adapting a .NET IFiberDataSet.
-        Args:
-            net_fiber_data_set_info: The .NET fiber data set to be adapted.
-        """
-        super().__init__(net_fiber_data_set_info)
-
-    description = dna.dom_property('description', 'Description')
-    type = dna.dom_property('type', 'Type')
-    unit = dna.dom_property('unit', 'Unit of this data set')
-    min = dna.dom_property('min', 'Minimum value of this data set')
-    max = dna.dom_property('max', 'Maximum value of this data set')

orchid/native_monitor_adapter.py

@@ -1,67 +0,0 @@
-#
-# This file is part of Orchid and related technologies.
-#
-# Copyright (c) 2017-2025 KAPPA.  All Rights Reserved.
-#
-# LEGAL NOTICE:
-# Orchid contains trade secrets and otherwise confidential information
-# owned by KAPPA. Access to and use of this information is
-# strictly limited and controlled by the Company. This file may not be copied,
-# distributed, or otherwise disclosed outside of the Company's facilities 
-# except under appropriate precautions to maintain the confidentiality hereof, 
-# and may not be used in any way not expressly authorized by the Company.
-#
-
-import pendulum
-
-import orchid.base
-from orchid import (
-    dot_net_dom_access as dna,
-    dom_project_object as dpo,
-    native_time_series_adapter as tsa,
-    net_date_time as ndt,
-)
-
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics.Monitors import ITimeSeriesMonitor
-
-
-class NativeMonitorAdapter(dpo.DomProjectObject):
-    """Adapts a native ITimeSeriesMonitor to python."""
-    def __init__(self, net_monitor: ITimeSeriesMonitor):
-        """
-        Constructs an instance adapting a .NET ITimeSeriesMonitor.
-
-        Args:
-            net_monitor: The .NET monitor to be adapted.
-        """
-        super().__init__(net_monitor, orchid.base.constantly(net_monitor.Project))
-
-    start_time = dna.transformed_dom_property('start_time', 'The start time of this monitor.',
-                                              ndt.as_date_time)
-    stop_time = dna.transformed_dom_property('stop_time', 'The stop time of this monitor.',
-                                             ndt.as_date_time)
-    well_time_series = dna.transformed_dom_property(
-        'time_series',
-        """The complete time series for the well that may be monitoring treatments.
-        
-        The returned time series contains all samples recorded for the project. More specifically, it may
-        contain samples either before or after `time_range()`.
-        
-        Another consequence of this definition is that if a client wants to access sample inside 
-        `time_range()`, one must write code to manually filter the series samples to only include the samples
-        in `time_range()`.
-        """,
-        tsa.NativeTimeSeriesAdapter)
-
-    @property
-    def time_range(self):
-        """
-        Calculate the time range during which this monitor is active; that is, monitoring the treatment stage.
-
-        Returns:
-            The time range during which this monitor is active. The type of the returned value is
-            `pendulum.Interval`. See the [documentation](https://pendulum.eustace.io/docs/) to understand the
-            methods available from a `pendulum.Interval` instance.
-        """
-        return pendulum.Interval(self.start_time, self.stop_time)