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

orchid/searchable_project_objects.py

@@ -1,190 +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 typing import Callable, Iterator, Optional
-import uuid
-
-import toolz.curried as toolz
-
-from orchid import dom_project_object as dpo
-
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics import IProjectObject
-
-
-class SearchableProjectError(ValueError):
-    """
-    Raised when an error occurs searching for a `dpo.DomProjectObject`.
-    """
-    pass
-
-
-class SearchableProjectMultipleMatchError(SearchableProjectError):
-    """
-    Raised when multiple matches occur when searching for a `dpo.DomProjectObject`.
-    """
-    pass
-
-
-"""
-Provides a searchable collection of `DomProjectObject` instances. This searchable collection provide methods to:
-
-- Query for all object IDs identifying instances in this collection
-- Query for all objects in this collection
-- Query for the name of all instances in this collection
-- Query for the display name of all instances in this collection
-- Search for a single instance by object ID
-- Search for all instances with a specified name
-- Search for all instances with a specified display name
-
-Here are the DOM objects that currently may be collections:
-- Data frames
-- Monitors
-- Stages
-- Stage Parts
-- Well trajectory
-- Wells
-
-This objects are all derived from `IProjectObject`. The corresponding instances in the Python API all derive from 
-`dpo.DomProjectObject` which implements the attributes `object_id`, `name` and `display_name`.
-"""
-
-
-class SearchableProjectObjects:
-    def __init__(self, make_adapter: Callable, net_project_objects: Iterator[IProjectObject]):
-        """
-        Construct a collection of project objects created my `make_adapter` using the arguments, `net_project_objects`.
-        Args:
-            make_adapter: The callable that constructs adapter instances using `net_project_objects`.
-            net_project_objects: The sequence of .NET `IProjectObject` instances adapted by the Python API.
-        """
-        def add_project_object_to_collection(so_far, update_po):
-            return toolz.assoc(so_far, update_po.object_id, update_po)
-        
-        self._collection = toolz.pipe(
-            net_project_objects,
-            toolz.map(make_adapter),
-            lambda pos: toolz.reduce(add_project_object_to_collection, pos, {}),
-        )
-
-    def __iter__(self):
-        """
-        Return an iterator over the items in this collection.
-
-        Returns:
-            An iterator over the items in this collection.
-        """
-        # TODO: Change this implementation to be more "fundamental" than `all_objects()`.
-        # The implementation of this method currently calls `all_objects()`. I think this implementation
-        # is not quite correct; instead, `all_objects()` should call this method (even if indirectly) which
-        # should return an iterator over `self._collection.values()`.
-        #
-        # Because we have not tested the Orchid Python API much this quarter, because we are creating a
-        # release, and because I do not want to destabilize the release at this time, I have chosen to
-        # leave the implementation of `all_objects()` as is and implement this method in terms of
-        # `all_objects()`. (FYI: I did prototype "switching" the implementations and all unit tests passed.)
-        return iter(self.all_objects())
-
-    def __len__(self):
-        """
-        Return the number of items in this collection.
-
-        Returns:
-            The number of items in this collection.
-        """
-        return len(self._collection)
-
-    def all_display_names(self) -> Iterator[str]:
-        """
-        Return an iterator over all the display names of project objects in this collection.
-
-        Returns:
-            An iterator over all the display names of project objects in this collection.
-        """
-        return toolz.map(lambda po: po.display_name, self._collection.values())
-
-    def all_names(self) -> Iterator[str]:
-        """
-        Return an iterator over all the names of project objects in this collection.
-
-        Returns:
-            An iterator over all the names of project objects in this collection.
-        """
-        return toolz.map(lambda po: po.name, self._collection.values())
-
-    def all_object_ids(self) -> Iterator[uuid.UUID]:
-        """
-        Return an iterator over all the object IDs of project objects in this collection.
-
-        Returns:
-            An iterator over all the object IDs of project objects in this collection.
-        """
-        return self._collection.keys()
-
-    def all_objects(self) -> Iterator[dpo.DomProjectObject]:
-        """
-        Return an iterator over all the projects objects in this collection.
-
-        Returns:
-            An iterator over all the project objects in this collection.
-        """
-        return self._collection.values()
-
-    def find(self, predicate: Callable) -> Iterator[dpo.DomProjectObject]:
-        """
-        Return an iterator over all project objects for which `predicate` returns `True`.
-
-        Args:
-            predicate: The `boolean` `Callable` to be invoked for each `dpo.DomProjectObject` in the collection.
-
-        Returns:
-            An iterator over all project objects fulfilling `predicate`.
-        """
-        return toolz.filter(predicate, self._collection.values())
-
-    def find_by_display_name(self, display_name_to_find: str) -> Iterator[dpo.DomProjectObject]:
-        """
-        Return an iterator over all project objects whose `display_name` is the `display_name_to_find`.
-
-        Args:
-            display_name_to_find: The display name for all project objects of interest.
-
-        Returns:
-            An iterator over all project objects with the specified `display_name` property.
-        """
-        return self.find(lambda po: po.display_name == display_name_to_find.strip())
-
-    def find_by_name(self, name_to_find: str) -> Iterator[dpo.DomProjectObject]:
-        """
-        Return an iterator over all project objects whose `name` is the `name_to_find`.
-
-        Args:
-            name_to_find: The name for all project objects of interest.
-
-        Returns:
-            An iterator over all project objects with the specified `name` property.
-        """
-        return self.find(lambda po: po.name == name_to_find.strip())
-
-    def find_by_object_id(self, object_id_to_find: uuid.UUID) -> Optional[dpo.DomProjectObject]:
-        """
-        Return the project object whose `object_id` is the `object_id_to_find` if available; otherwise, `None`.
-
-        Args:
-            object_id_to_find: The object ID for the project objects of interest.
-
-        Returns:
-            The project objects with the specified `name` property. If no such project is found, return `None`.
-        """
-        return toolz.get(object_id_to_find, self._collection, default=None)

orchid/searchable_stage_parts.py

@@ -1,73 +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 typing import Iterable, Optional
-
-
-from orchid import (
-    native_stage_part_adapter as spa,
-    searchable_project_objects as spo,
-)
-
-
-class SearchableStageParts(spo.SearchableProjectObjects):
-    def find_by_part_number(self, to_find: int) -> Optional[spa.NativeStagePartAdapter]:
-        """
-        Find a stage part with the specified part number.
-
-        Args:
-            to_find: The part number sought.
-
-        Returns:
-            The stage part with the specified part number.
-
-            If no such stage part is found, returns `None`. If multiple stage parts with the specified part number are
-            found, raises `spo.SearchableProjectMultipleMatchError`.
-        """
-        candidates = list(self.find(lambda s: s.part_no == to_find))
-        if len(candidates) == 0:
-            return None
-        elif len(candidates) == 1:
-            return candidates[0]
-        else:
-            raise spo.SearchableProjectMultipleMatchError(to_find)
-
-    def find_by_display_name_with_well(self, to_find: str) -> Iterable[spa.NativeStagePartAdapter]:
-        """
-        Find a stage part with the specified display name with well.
-
-        Args:
-            to_find: The display name with well sought.
-
-        Returns:
-            The matching stage part(s).
-
-            If no such stage part is in this collection, returns an empty iterator.
-        """
-        return self.find(lambda s: s.display_name_with_well == to_find)
-
-    def find_by_display_name_without_well(self, to_find: str) -> Iterable[spa.NativeStagePartAdapter]:
-        """
-        Find a stage part without the specified display name with well.
-
-        Args:
-            to_find: The display name without well sought.
-
-        Returns:
-            The matching stage part(s).
-
-            If no such stage part is in this collection, returns an empty iterator.
-        """
-        return self.find(lambda s: s.display_name_without_well == to_find)

orchid/searchable_stages.py

@@ -1,29 +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 orchid import searchable_project_objects as spo
-
-
-class SearchableStages(spo.SearchableProjectObjects):
-    def find_by_display_stage_number(self, to_find: int):
-        candidates = list(self.find(lambda s: s.display_stage_number == to_find))
-        if len(candidates) == 0:
-            return None
-        elif len(candidates) == 1:
-            return candidates[0]
-        else:
-            raise spo.SearchableProjectMultipleMatchError(to_find)
-
-    def find_by_display_name_with_well(self, to_find: str):
-        return self.find(lambda s: s.display_name_with_well == to_find)

orchid/unit_system.py

@@ -1,173 +0,0 @@
-# Copyright (c) 2017-2025 KAPPA.  All Rights Reserved.
-#
-# This file is part of Orchid and related technologies.
-#
-# 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 abc import abstractmethod
-from collections import namedtuple
-from enum import Enum
-import numbers
-
-import toolz.curried as toolz
-
-from orchid import (
-    measurement as om,
-    physical_quantity as opq,
-)
-
-
-# noinspection PyUnresolvedReferences
-from Orchid.FractureDiagnostics import UnitSystem as NetUnitSystem
-# noinspection PyUnresolvedReferences
-import UnitsNet
-
-
-# I use this private class to distinguish units that measure **different** physical quantities but use the
-# same measurement unit. Currently, this applies to DENSITY and PRESSURE.
-_AboutUnit = namedtuple('AboutUnit', ['unit', 'physical_quantity'])
-
-
-class UnitSystem(Enum):
-
-    def __str__(self):
-        """
-        Return a string representation of the member.
-
-        Returns:
-            The string representing the enumeration member.
-        """
-        return f'{self.value.unit}'
-
-    def abbreviation(self):
-        """
-        Return the abbreviation for a unit.
-
-        Returns:
-            The abbreviation of 'unit'.
-        """
-        return f'{self.value.unit:~P}'
-
-    @abstractmethod
-    def system_name(self):
-        raise NotImplementedError()
-
-
-class Common(UnitSystem):
-    """The enumeration of units common to both U. S. oilfield and metric unit systems."""
-
-    ANGLE = _AboutUnit(om.registry.deg, opq.PhysicalQuantity.ANGLE)
-    DURATION = _AboutUnit(om.registry.min, opq.PhysicalQuantity.DURATION)
-
-    def system_name(self):
-        return 'Common'
-
-
-class UsOilfield(UnitSystem):
-    """The enumeration of U. S. oilfield units available via the Orchid Python API."""
-
-    DENSITY = _AboutUnit(om.registry.pound / om.registry.ft ** 3, opq.PhysicalQuantity.DENSITY)
-    ENERGY = _AboutUnit(om.registry.foot_pound, opq.PhysicalQuantity.ENERGY)
-    FORCE = _AboutUnit(om.registry.pound_force, opq.PhysicalQuantity.FORCE)
-    LENGTH = _AboutUnit(om.registry.foot, opq.PhysicalQuantity.LENGTH)
-    MASS = _AboutUnit(om.registry.pound, opq.PhysicalQuantity.MASS)
-    POWER = _AboutUnit(om.registry.horsepower, opq.PhysicalQuantity.POWER)
-    PRESSURE = _AboutUnit(om.registry.pound_force_per_square_inch, opq.PhysicalQuantity.PRESSURE)
-    PROPPANT_CONCENTRATION = _AboutUnit(om.registry.pound / om.registry.gallon,
-                                        opq.PhysicalQuantity.PROPPANT_CONCENTRATION)
-    SLURRY_RATE = _AboutUnit(om.registry.oil_barrel / om.registry.minute, opq.PhysicalQuantity.SLURRY_RATE)
-    TEMPERATURE = _AboutUnit(om.registry.degree_Fahrenheit, opq.PhysicalQuantity.TEMPERATURE)
-    VOLUME = _AboutUnit(om.registry.oil_barrel, opq.PhysicalQuantity.VOLUME)
-
-    def system_name(self):
-        return 'USOilfield'
-
-
-class Metric(UnitSystem):
-    """The enumeration of metric units available via the Orchid Python API."""
-
-    DENSITY = _AboutUnit(om.registry.kilogram / om.registry.meter ** 3, opq.PhysicalQuantity.DENSITY)
-    ENERGY = _AboutUnit(om.registry.joule, opq.PhysicalQuantity.ENERGY)
-    FORCE = _AboutUnit(om.registry.newton, opq.PhysicalQuantity.FORCE)
-    LENGTH = _AboutUnit(om.registry.meter, opq.PhysicalQuantity.LENGTH)
-    MASS = _AboutUnit(om.registry.kilogram, opq.PhysicalQuantity.MASS)
-    POWER = _AboutUnit(om.registry.watt, opq.PhysicalQuantity.POWER)
-    PRESSURE = _AboutUnit(om.registry.kilopascal, opq.PhysicalQuantity.PRESSURE)
-    PROPPANT_CONCENTRATION = _AboutUnit(om.registry.kilogram / om.registry.meter ** 3,
-                                        opq.PhysicalQuantity.PROPPANT_CONCENTRATION)
-    SLURRY_RATE = _AboutUnit(om.registry.meter ** 3 / om.registry.minute, opq.PhysicalQuantity.SLURRY_RATE)
-    TEMPERATURE = _AboutUnit(om.registry.degree_Celsius, opq.PhysicalQuantity.TEMPERATURE)
-    VOLUME = _AboutUnit((om.registry.m ** 3), opq.PhysicalQuantity.VOLUME)
-
-    def system_name(self):
-        return 'Metric'
-
-
-def as_unit_system(net_unit_system: UnitSystem):
-    if net_unit_system == NetUnitSystem.USOilfield():
-        return UsOilfield
-    elif net_unit_system == NetUnitSystem.Metric():
-        return Metric
-    else:
-        raise ValueError(f'Unrecognized unit system: {net_unit_system}')
-
-
-@toolz.curry
-def make_measurement(unit: UnitSystem, magnitude: numbers.Real) -> om.Quantity:
-    """
-    Construct a measurement.
-
-    This function provides a "functional" mechanism to create Measurement instances. It is more common to
-    create a sequence of measurements from a sequence of numbers and a **single** unit. By putting the `unit`
-    argument first in the function arguments, it allows callers to write code similar to the following:
-
-    > make_length_measurement = make_measurement(units.UsOilfield.LENGTH)
-    > length_measurements = [make_length_measurement(l) for l in lengths]
-    > # or toolz.map(make_length_measurement, lengths)
-
-    Args:
-        unit: The unit of this measurement.
-        magnitude: The magnitude of the measurement.
-
-    Returns:
-        The created `pint` `Quantity` instance.
-    """
-    return om.Quantity(magnitude, unit.value.unit)
-
-
-make_us_oilfield_length_measurement = make_measurement(UsOilfield.LENGTH)
-make_us_oilfield_pressure_measurement = make_measurement(UsOilfield.PRESSURE)
-
-make_metric_length_measurement = make_measurement(Metric.LENGTH)
-make_metric_pressure_measurement = make_measurement(Metric.PRESSURE)
-
-
-def is_length_unit(candidate) -> bool:
-    return candidate.check('[length]')
-
-
-def is_pressure_unit(candidate) -> bool:
-    return candidate.check('[pressure]')
-
-
-def abbreviation(unit: UnitSystem):
-    """
-    Return the abbreviation of `unit`.
-
-    This function provides a functional interface for calculating abbreviations of `UnitSystem` members.
-
-    Args:
-        unit: The `UnitSystem` member whose abbreviation is sought.
-
-    Returns:
-        The abbreviation for `unit`.
-    """
-    return unit.abbreviation()

orchid/utils.py

@@ -1,14 +0,0 @@
-from datetime import datetime
-
-FORMATS = [
-    '%d/%m/%Y %H:%M:%S',       # e.g., 16/04/2019 23:45:10
-    '%m/%d/%Y %I:%M:%S %p',    # e.g., 4/16/2019 12:02:51 AM
-]
-
-def convert_dotnet_datetime_to_python_datetime(csharp_datetime_str: str) -> datetime:
-    for fmt in FORMATS:
-        try:
-            return datetime.strptime(csharp_datetime_str, fmt)
-        except ValueError:
-            continue
-    raise ValueError(f"Unrecognized datetime format: '{csharp_datetime_str}'")

orchid/validation.py

@@ -1,52 +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.
-#
-
-"""This module contains common functions used to validate arguments."""
-
-
-from orchid import (unit_system as units)
-
-
-def arg_not_none(_, arg) -> bool:
-    """
-    Tests if the single argument is not None
-
-    :param _: Ignored (typically mapped to `self` for bound methods)
-    :param arg: The argument to be tested
-    :return: True if arg is not None; otherwise, false.
-    """
-    return arg is not None
-
-
-def arg_neither_empty_nor_all_whitespace(_, arg: str) -> bool:
-    """
-    Tests if the single argument is not None
-
-    :param _: Ignored (typically mapped to `self` for bound methods)
-    :param arg: The argument to be tested
-    :return: True if arg is neither an empty string nor a string consisting only of whitespace.
-    """
-    return len(arg.strip()) > 0
-
-
-def arg_is_acceptable_pressure_unit(_, target_unit):
-    return (target_unit == units.UsOilfield.PRESSURE) or (target_unit == units.Metric.PRESSURE)
-
-
-def is_unit_system_length(unit_to_test):
-    return unit_to_test == units.UsOilfield.LENGTH or unit_to_test == units.Metric.LENGTH
-

orchid/version.py

@@ -1,37 +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 re
-import pathlib
-
-
-def get_orchid_sdk_version():
-    """
-    Calculate the Python API version.
-
-    Returns:
-        The Python API version read from the `VERSION` file.
-    """
-    try:
-        with pathlib.Path(__file__).parent.joinpath('VERSION').open() as version_file:
-            text_version = version_file.read()
-            version_match = re.search(r'\d+\.\d+\.\d+(?:\.\d+)?', text_version)
-            if version_match:
-                return version_match.group()
-            else:
-                raise ValueError("Cannot find a correct version number in VERSION file.")
-    except FileNotFoundError:
-        raise FileNotFoundError("Missing VERSION file")