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

orchid/physical_quantity.py

@@ -1,37 +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.
-#
-
-
-from enum import Enum
-
-# noinspection PyUnresolvedReferences
-import UnitsNet
-
-
-class PhysicalQuantity(Enum):
-    """The enumeration of physical quantities available via the Orchid Python API."""
-
-    ANGLE = 'angle'
-    DENSITY = 'density'
-    DURATION = 'duration'
-    ENERGY = 'energy'
-    FORCE = 'force'
-    LENGTH = 'length'
-    MASS = 'mass'
-    POWER = 'power'
-    PRESSURE = 'pressure'
-    PROPPANT_CONCENTRATION = 'proppant concentration'
-    SLURRY_RATE = 'slurry rate'
-    TEMPERATURE = 'temperature'
-    VOLUME = 'volume'

orchid/project.py

@@ -1,182 +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.
-#
-
-from collections import namedtuple
-from typing import Iterable, List, Tuple
-
-import deal
-import option
-import toolz.curried as toolz
-
-from orchid import (
-    dot_net_dom_access as dna,
-    native_data_frame_adapter as dfa,
-    native_fiber_data as nfd,
-    native_monitor_adapter as nma,
-    native_time_series_adapter as tsa,
-    native_project_user_data_adapter as uda,
-    native_well_adapter as nwa,
-    net_quantity as onq,
-    searchable_data_frames as sdf,
-    searchable_project_objects as spo,
-    unit_system as units,
-)
-from orchid.project_store import ProjectStore
-
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from Orchid.FractureDiagnostics import IWell, UnitSystem
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from Orchid.FractureDiagnostics.Settings import IProjectUserData
-# noinspection PyUnresolvedReferences
-import UnitsNet
-
-
-ProjectBounds = namedtuple('ProjectBounds', [
-    'min_x', 'max_x',
-    'min_y', 'max_y',
-    'min_depth', 'max_depth',
-])
-SurfacePoint = namedtuple('SurfacePoint', ['x', 'y'])
-
-
-class Project(dna.IdentifiedDotNetAdapter):
-    """Adapts a .NET `IProject` to a Pythonic interface."""
-
-    @deal.pre(lambda self, project_loader: project_loader is not None)
-    def __init__(self, project_loader: ProjectStore):
-        """
-        Construct an instance adapting the .NET IProject.
-
-        project_loader: Loads an IProject to be adapted.
-        """
-        super().__init__(project_loader.native_project())
-        self._project_loader = project_loader
-
-    azimuth = dna.transformed_dom_property('azimuth', 'The azimuth of the project measured east of north.',
-                                           toolz.compose(onq.as_measurement(units.Common.ANGLE),
-                                                         option.maybe))
-    name = dna.dom_property('name', 'The name of this project.')
-    project_units = dna.transformed_dom_property('project_units', 'The project unit system.', units.as_unit_system)
-
-    # _data_frames = dna.map_reduce_dom_property('data_frames', 'The project data frames.',
-    #                                            dfa.NativeDataFrameAdapterIdentified, dna.dictionary_by_id, {})
-
-    @property
-    def fluid_density(self):
-        """The fluid density of the project in project units."""
-        return onq.as_measurement(self.project_units.DENSITY, option.maybe(self.dom_object.FluidDensity))
-
-    def data_frames(self) -> spo.SearchableProjectObjects:
-        """
-        Return a `spo.SearchableProjectObjects` instance of all the data frames for this project.
-
-        Returns:
-            An `spo.SearchableProjectObjects` for all the data frames of this project.
-        """
-        return sdf.SearchableDataFrames(dfa.NativeDataFrameAdapterIdentified, self.dom_object.DataFrames.Items)
-
-    def default_well_colors(self) -> List[Tuple[float, float, float]]:
-        """
-        Calculate the default well colors for this project.
-        :return: A list of RGB tuples.
-        """
-        result = list(map(tuple, self._project_loader.native_project().PlottingSettings.GetDefaultWellColors()))
-        return result
-
-    def monitors(self) -> spo.SearchableProjectObjects:
-        """
-        Return a `spo.SearchableProjectObjects` instance of all the monitors for this project.
-
-        Returns:
-            An `spo.SearchableProjectObjects` for all the monitors of this project.
-        """
-        return spo.SearchableProjectObjects(nma.NativeMonitorAdapter, self.dom_object.Monitors.Items)
-
-    def fiber_data(self) -> List[nfd.NativeFiberData]:
-        """
-        Return a `spo.SearchableProjectObjects` instance of all the fiber data for this project.
-
-        Returns:
-            An `spo.SearchableProjectObjects` for all the monitors of this project.
-        """
-        return list(spo.SearchableProjectObjects(nfd.NativeFiberData, self.dom_object.FiberDataSets.Items))
-
-    def project_bounds(self) -> ProjectBounds:
-        result = toolz.pipe(self.dom_object.GetProjectBounds(),
-                            toolz.map(option.maybe),
-                            toolz.map(onq.as_measurement(self.project_units.LENGTH)),
-                            list,
-                            lambda ls: ProjectBounds(*ls))
-        return result
-
-    def project_center(self) -> SurfacePoint:
-        """
-        Return the location of the project center on the surface measured in project units.
-        """
-        net_center = self.dom_object.GetProjectCenter()
-        result = toolz.pipe(net_center,
-                            toolz.map(option.maybe),
-                            toolz.map(onq.as_measurement(self.project_units.LENGTH)),
-                            list,
-                            lambda ls: SurfacePoint(ls[0], ls[1]))
-        return result
-
-    def proppant_concentration_mass_unit(self):
-        if self.project_units == units.UsOilfield:
-            return units.UsOilfield.MASS
-        elif self.project_units == units.Metric:
-            return units.Metric.MASS
-        else:
-            raise ValueError(f'Unknown unit system: {self.project_units}')
-
-    def slurry_rate_volume_unit(self):
-        if self.project_units == units.UsOilfield:
-            return units.UsOilfield.VOLUME
-        elif self.project_units == units.Metric:
-            return units.Metric.VOLUME
-        else:
-            raise ValueError(f'Unknown unit system: {self.project_units}')
-
-    def time_series(self) -> spo.SearchableProjectObjects:
-        """
-        Return a `spo.SearchableProjectObjects` instance of all the time series for this project.
-
-        Returns:
-            An `spo.SearchableProjectObjects` for all the time series of this project.
-        """
-        return spo.SearchableProjectObjects(tsa.NativeTimeSeriesAdapter, self.dom_object.WellTimeSeriesList.Items)
-
-    @property
-    def user_data(self) -> uda.NativeProjectUserDataAdapter:
-        return uda.NativeProjectUserDataAdapter(self.dom_object.ProjectUserData)
-
-    def wells(self) -> spo.SearchableProjectObjects:
-        """
-        Return a `spo.SearchableProjectObjects` instance of all the wells for this project.
-
-        Returns:
-            An `spo.SearchableProjectObjects` for all the wells of this project.
-        """
-        return spo.SearchableProjectObjects(nwa.NativeWellAdapter, self.dom_object.Wells.Items)
-
-    def wells_by_name(self, name: str) -> Iterable[IWell]:
-        """
-        Return all the wells in this project with the specified name.
-
-        name: The name of the well(s) of interest.
-        """
-        return toolz.filter(lambda w: name == w.name, self.wells)

orchid/project_store.py

@@ -1,269 +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 functools
-import pathlib
-from typing import Union
-
-import deal
-import option
-import toolz.curried as toolz
-
-from orchid import (
-    dot_net,
-    dot_net_disposable as dnd,
-    script_adapter_context as sac,
-    validation,
-)
-
-# noinspection PyUnresolvedReferences
-from System import InvalidOperationException, TimeZoneInfo
-# noinspection PyUnresolvedReferences
-from System.IO import (FileStream, FileMode, FileAccess, FileShare)
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics.SDKFacade import (
-    PythonTimesSeriesArraysDto,
-    ScriptAdapter,
-)
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics.TimeSeries import IQuantityTimeSeries
-
-# To support doctests only
-import json
-import shutil
-import zipfile
-
-import orchid
-
-
-class OrchidError(Exception):
-    pass
-
-
-# Ensure that a pathname is a string. Useful especially for converting `pathlib.Path` instances.
-pathname_to_str = toolz.compose(str, toolz.identity)
-
-
-def as_python_time_series_arrays(native_time_series: IQuantityTimeSeries):
-    """
-    Calculate the Python time series arrays equivalent to the `native_time_series` samples.
-    Args:
-        native_time_series: The native time series whose samples are sought.
-
-    Returns:
-        A `PythonTimeSeriesArraysDto` containing two arrays:
-        - Sample magnitudes
-        - Unix time stamps in seconds
-    """
-    with sac.ScriptAdapterContext():
-        result = ScriptAdapter.AsPythonTimeSeriesArrays(native_time_series)
-    return result
-
-
-@functools.lru_cache()
-def native_treatment_calculations():
-    """
-    Returns a .NET ITreatmentCalculations instance to be adapted.
-
-    Returns:
-            An `ITreatmentCalculations` implementation.
-    """
-    with sac.ScriptAdapterContext():
-        result = ScriptAdapter.CreateTreatmentCalculations()
-    return result
-
-
-class ProjectStore:
-    """Provides an .NET IProject to be adapted."""
-
-    # TODO: consider changing `project_pathname` to be `pathlib.Path`
-    @deal.pre(validation.arg_not_none)
-    @deal.pre(validation.arg_neither_empty_nor_all_whitespace)
-    def __init__(self, project_pathname: str):
-        """
-        Construct an instance that loads project data from project_pathname
-
-        Args:
-            project_pathname: Identifies the data file for the project of interest.
-        """
-        self._project_pathname = pathlib.Path(project_pathname)
-        self._native_project = None
-        self._in_context = False
-
-    def native_project(self):
-        """
-        Return the native (.NET) Orchid project.
-
-        Returns:
-            The loaded `IProject`.
-        """
-        if self._native_project is None:
-            self.load_project()
-        return self._native_project
-
-    def load_project(self):
-        """
-        Load a project from the path, `self._project_pathname`.
-
-        Examples:
-            >>> load_path = orchid.training_data_path().joinpath('frankNstein_Bakken_UTM13_FEET.ifrac')
-            >>> store = ProjectStore(pathname_to_str(load_path))
-            >>> store.load_project()
-            >>> loaded_project = store.native_project()
-            >>> loaded_project.Name
-            'frankNstein_Bakken_UTM13_FEET'
-        """
-        with sac.ScriptAdapterContext():
-            reader = ScriptAdapter.CreateProjectFileReader(dot_net.app_settings_path())
-            self._native_project = reader.Read(pathname_to_str(self._project_pathname), TimeZoneInfo.Utc)
-
-    def save_project(self, project):
-        """
-        Save the specified project to `self._project_pathname`.
-
-
-        Args:
-            project: The project to be saved.
-
-        Examples:
-            >>> # Test saving changed project
-            >>> load_path = orchid.training_data_path().joinpath('frankNstein_Bakken_UTM13_FEET.ifrac')
-            >>> # Use `orchid.core.load_project` to avoid circular dependency with `orchid.project`
-            >>> changed_project = orchid.load_project(pathname_to_str(load_path))
-            >>> # TODO: move this code to the property eventually, I think.
-            >>> with (dnd.disposable(changed_project.dom_object.ToMutable())) as mnp:
-            ...     mnp.Name = 'nomen mutatum'
-            >>> save_path = load_path.with_name(f'nomen mutatum{load_path.suffix}')
-            >>> save_store = ProjectStore(pathname_to_str(save_path))
-            >>> save_store.save_project(changed_project)
-            >>> save_path.exists()
-            True
-            >>> with zipfile.ZipFile(save_path) as archive:
-            ...     content = json.loads(archive.read('project.json'))
-            ...     content['Object']['Name']
-            'nomen mutatum'
-            >>> save_path.unlink()
-            >>> # Test side_effect of `save_project`: `native_project` returns project that was saved
-            >>> # I do not expect end users to utilize this side-effect.
-            >>> # TODO: Because this code tests a side-effect, an actual unit test might be better.
-            >>> load_path = orchid.training_data_path().joinpath('frankNstein_Bakken_UTM13_FEET.ifrac')
-            >>> # Use `orchid.core.load_project` to avoid circular dependency with `orchid.project`
-            >>> changed_project = orchid.load_project(pathname_to_str(load_path))
-            >>> # TODO: move this code to the property eventually, I think.
-            >>> with (dnd.disposable(changed_project.dom_object.ToMutable())) as mnp:
-            ...     mnp.Name = 'mutatio project'
-            >>> save_path = load_path.with_name(f'mutatio project{load_path.suffix}')
-            >>> save_store = ProjectStore(pathname_to_str(save_path))
-            >>> save_store.save_project(changed_project)
-            >>> changed_project.dom_object == save_store.native_project()
-            True
-            >>> save_path.unlink()
-        """
-        with sac.ScriptAdapterContext():
-            writer = ScriptAdapter.CreateProjectFileWriter()
-            use_binary_format = False
-            writer.Write(project.dom_object, pathname_to_str(self._project_pathname), use_binary_format)
-        self._native_project = project.dom_object
-
-    def optimized_but_possibly_unsafe_save(self, project, maybe_to_pathname: option.Option[Union[str, pathlib.Path]]):
-        """
-        Saves `project` `to_pathname` is an optimized, but possibly "unsafe" manner.
-
-        This method is unsafe because it only writes some data from `project`; the remainder of the data is simply
-        (bulk) copied from the `project_pathname` supplied to the constructor.
-
-        This method assumes that `project` was originally loaded from `project_pathname` and was then changed in
-        such a way that the "bulk" data **was not** changed. If this assumption is not true, the project saved in
-        `to_pathname` will **not** contain all the changes to `project`.
-
-        Specifically, this method **does not** save changes to data like:
-
-        - Trajectories
-        - Treatment curves
-        - Monitor curves
-
-        We believe that this method will generally finish more quickly than `save_project`; however, we cannot
-        guarantee this behavior. We encourage the developer calling this method to perform her own performance tests
-        and to understand if his use case meets the assumptions made by this method.
-
-        Args:
-            project: The project to be saved.
-            maybe_to_pathname: The "target" pathname for the newly saved data.
-
-        Examples:
-            >>> # Test optimized saving of changed project
-            >>> load_path = orchid.training_data_path().joinpath('Project_frankNstein_Permian_UTM13_FEET.ifrac')
-            >>> # Use `orchid.core.load_project` to avoid circular dependency with `orchid.project`
-            >>> changed_project = orchid.load_project(pathname_to_str(load_path))
-            >>> # TODO: eventually move this code to a project property, I think.
-            >>> with (dnd.disposable(changed_project.dom_object.ToMutable())) as mnp:
-            ...     mnp.Name = 'permanet melius'
-            >>> save_path = load_path.with_name(f'permanet melius{load_path.suffix}')
-            >>> # Remember original path used to load `changed_project`
-            >>> changed_project_store = ProjectStore(pathname_to_str(load_path))
-            >>> changed_project_store.optimized_but_possibly_unsafe_save(changed_project, option.maybe(save_path))
-            >>> save_path.exists()
-            True
-            >>> with zipfile.ZipFile(save_path) as archive:
-            ...     content = json.loads(archive.read('project.json'))
-            ...     content['Object']['Name']
-            'permanet melius'
-            >>> save_path.unlink()
-            >>> # Test side_effect of `save_project`: `native_project` returns project that was saved
-            >>> # I do not expect end users to utilize this side-effect.
-            >>> # TODO: Because this code tests a side-effect, an actual unit test might be better.
-            >>> load_path = orchid.training_data_path().joinpath('Project_frankNstein_Permian_UTM13_FEET.ifrac')
-            >>> # Use `orchid.core.load_project` to avoid circular dependency with `orchid.project`
-            >>> changed_project = orchid.load_project(pathname_to_str(load_path))
-            >>> # TODO: move this code to the property eventually, I think.
-            >>> with (dnd.disposable(changed_project.dom_object.ToMutable())) as mnp:
-            ...     mnp.Name = 'mutatio project melius'
-            >>> save_path = load_path.with_name(f'mutatio project melius{load_path.suffix}')
-            >>> # Remember original path used to load `changed_project`
-            >>> changed_project_store = ProjectStore(pathname_to_str(load_path))
-            >>> changed_project_store.optimized_but_possibly_unsafe_save(changed_project, option.maybe(save_path))
-            >>> changed_project.dom_object == changed_project_store.native_project()
-            True
-            >>> save_path.unlink()
-            >>> # Test supplying **no** `maybe_to_pathname`
-            >>> source_path = orchid.training_data_path().joinpath('Project_frankNstein_Permian_UTM13_FEET.ifrac')
-            >>> load_path = source_path.with_name(f'idem filum{source_path.suffix}')
-            >>> # ignore returned result for doctest
-            >>> _to_path = shutil.copyfile(pathname_to_str(source_path), pathname_to_str(load_path))
-            >>> # Use `orchid.core.load_project` to avoid circular dependency with `orchid.project`
-            >>> changed_project = orchid.load_project(pathname_to_str(load_path))
-            >>> # TODO: eventually move this code to a project property, I think.
-            >>> with (dnd.disposable(changed_project.dom_object.ToMutable())) as mnp:
-            ...     mnp.Name = 'idem filum'
-            >>> changed_project_store = ProjectStore(pathname_to_str(load_path))
-            >>> changed_project_store.optimized_but_possibly_unsafe_save(changed_project, option.NONE)
-            >>> load_path.exists()
-            True
-            >>> load_path.unlink()
-        """
-        with sac.ScriptAdapterContext():
-            writer = ScriptAdapter.CreateProjectFileWriter()
-            use_binary_format = False
-            writer.Write(project.dom_object, pathname_to_str(self._project_pathname),
-                         maybe_to_pathname.map_or(pathname_to_str, pathname_to_str(self._project_pathname)),
-                         use_binary_format)
-        self._native_project = project.dom_object
-
-
-if __name__ == '__main__':
-    import doctest
-    doctest.testmod()

orchid/reference_origins.py

@@ -1,34 +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 enum
-
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from Orchid.FractureDiagnostics import WellReferenceFrameXy as NetWellReferenceFrameXy
-# noinspection PyUnresolvedReferences,PyPackageRequirements
-from Orchid.FractureDiagnostics import DepthDatum as NetDepthDatum
-
-
-# TODO: Consider adding base with methods like `toNetEnum` and `fromNetEnum`
-class WellReferenceFrameXy(enum.Enum):
-    ABSOLUTE_STATE_PLANE = NetWellReferenceFrameXy.AbsoluteStatePlane
-    PROJECT = NetWellReferenceFrameXy.Project
-    WELL_HEAD = NetWellReferenceFrameXy.WellHead
-
-
-# TODO: Consider adding base with methods like `toNetEnum` and `fromNetEnum`
-class DepthDatum(enum.Enum):
-    GROUND_LEVEL = NetDepthDatum.GroundLevel
-    KELLY_BUSHING = NetDepthDatum.KellyBushing
-    SEA_LEVEL = NetDepthDatum.SeaLevel

orchid/script_adapter_context.py

@@ -1,81 +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 sys
-
-import orchid.configuration
-
-import toolz.curried as toolz
-
-from pythonnet import load
-load('coreclr')
-
-# noinspection PyPackageRequirements
-import clr
-# noinspection PyUnresolvedReferences
-from System import InvalidOperationException
-
-
-def append_orchid_assemblies_directory_path() -> None:
-    """
-    Append the directory containing the required Orchid assemblies to `sys.path`.
-    """
-    orchid_bin_dir = toolz.get_in(['orchid', 'root'], orchid.configuration.get_configuration())
-    if orchid_bin_dir not in sys.path:
-        sys.path.append(orchid_bin_dir)
-
-
-append_orchid_assemblies_directory_path()
-
-clr.AddReference('Orchid.FractureDiagnostics.SDKFacade')
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics.SDKFacade import ScriptAdapter
-
-
-class ScriptAdapterContext:
-    """
-    A "private" class with the responsibility to initialize and shutdown the .NET ScriptAdapter class.
-
-    I considered making `ProjectStore` a context manager; however, the API then becomes somewhat unclear.
-
-        - Does the constructor enter the context? Must a caller initialize the instance and then enter the
-          context?
-        - What results if a caller *does not* enter the context?
-        - Enters the context twice?
-
-    Because I was uncertain I created this private class to model the `ScriptAdapter` context. The property,
-    `ProjectStore.native_project`, enters the context if it will actually read the project and exits the
-    context when the read operation is finished.
-
-    For information on Python context managers, see
-    [the Python docs](https://docs.python.org/3.8/library/stdtypes.html#context-manager-types)
-    """
-
-    def __enter__(self):
-        try:
-            ScriptAdapter.Init()
-            return self
-        # TODO: Correct exception type / DEADFALL issue
-        except InvalidOperationException as ioe:
-            if 'REVEAL-CORE-0xDEADFA11' in ioe.Message:
-                print('Orchid licensing error. Please contact Orchid technical support.')
-                sys.exit(-1)
-            else:
-                raise
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        ScriptAdapter.Shutdown()
-        # Returning no value will propagate the exception to the caller in the normal way
-        return

orchid/searchable_data_frames.py

@@ -1,44 +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 warnings
-from typing import Callable, Iterator
-
-import toolz.curried as toolz
-
-from orchid import searchable_project_objects as spo
-
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics import IProjectObject
-
-
-class SearchableDataFrames(spo.SearchableProjectObjects):
-    def __init__(self, make_adapter: Callable, net_project_objects: Iterator[IProjectObject]):
-        super(SearchableDataFrames, self).__init__(make_adapter, net_project_objects)
-
-        def has_duplicate_object_ids(pos):
-            return not toolz.pipe(
-                pos,
-                toolz.map(lambda npo: npo.ObjectId.ToString()),
-                toolz.isdistinct,
-            )
-
-        if has_duplicate_object_ids(net_project_objects):
-            warnings.warn("""
-            KNOWN ISSUE: Multiple data frames with duplicate object IDs detected.
-            
-            Workarounds:
-            - **DO NOT** use `find_by_object_id`; use `find_by_name` or `find_by_display_name` to search.
-            - Delete and recreate all data frames in a release of Orchid > 2022.3.
-            """)