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

orchid/configuration.py

@@ -1,162 +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 glob
-import logging
-import os
-import pathlib
-from typing import Dict, Any
-import warnings
-import toolz.curried as toolz
-import yaml
-
-from orchid.version import get_orchid_sdk_version
-
-
-_logger = logging.getLogger(__name__)
-
-
-class ConfigurationError(Exception):
-    pass
-
-
-# Constants for environment variable names
-ORCHID_ROOT_ENV_VAR = 'ORCHID_ROOT'
-ORCHID_TRAINING_DATA_ENV_VAR = 'ORCHID_TRAINING_DATA'
-
-
-def get_environment_configuration() -> Dict[str, Dict[str, str]]:
-    """
-    Gets the API configuration from the system environment.
-
-    Returns:
-        The configuration, if any, calculated from the system environment.
-    """
-    environment_configuration = {'orchid': {key: os.environ[env_var] for key, env_var in
-                                            [('root', ORCHID_ROOT_ENV_VAR), ('training_data', ORCHID_TRAINING_DATA_ENV_VAR)] if env_var in os.environ}}
-    _logger.debug(f'environment configuration = {environment_configuration}')
-    return environment_configuration
-
-
-def get_fallback_configuration() -> Dict[str, Dict[str, str]]:
-    """
-    Returns final fallback API configuration.
-
-    Returns:
-        A Python dictionary with the default (always available configuration).
-
-    Warning:
-        Although we have striven to make the default configuration a working configuration, we can only ensure
-        that the default configuration meets the minimal "syntax" required by the Python API. For example, if
-        Orchid is **not** installed in the default location, and the `directory` key is not overridden by a
-        higher priority configuration, the Python API will **fail** to load the Orchid assemblies and throw
-        an exception at runtime.
-    """
-
-    # Symbolically, the standard location for the installed Orchid binaries is
-    # `$ProgramFiles/Reveal Energy Services, Inc/Orchid/<version-specific-directory>`. The following code
-    # calculates an actual location by substituting the current version number for the symbol,
-    # `<version-specific-directory>`.
-    program_files_path = os.environ.get("ProgramFiles")
-    fallback = {}
-    if program_files_path is not None:
-        orchid_version = get_orchid_sdk_version() + '.*'
-        python_api_lib_pattern_path = os.path.join(program_files_path, 'Reveal Energy Services', 'Orchid', orchid_version, 'Orchid-'+orchid_version, 'PythonApiLibs')
-        matching_paths = glob.glob(python_api_lib_pattern_path)
-        if len(matching_paths) == 1:
-            python_api_lib_path = matching_paths[0]
-            _logger.info(f"PythonApiLibs path found : {python_api_lib_path}")
-            fallback = {'orchid': {'root': str(matching_paths[0])}}
-        elif len(matching_paths) == 0:
-            _logger.info(f"PythonApiLibs path not found for {str(python_api_lib_pattern_path)}")
-        else:
-            warnings.warn(f'Fallback configuration found multiple matches for {str(python_api_lib_pattern_path)}')
-        _logger.debug(f'fallback configuration={fallback}')
-    return fallback
-
-
-def get_file_configuration() -> Dict[str, Any]:
-    """
-    Returns the API configuration read from the file system.
-
-    Returns:
-        A python dictionary with the default (always available configuration).
-    """
-
-    # This code looks for the configuration file, `python_api.yaml`, in the `.orchid` sub-directory of the
-    # user-specific (and system-specific) home directory. See the Python documentation of `home()` for
-    # details.
-    file = {}
-    file_config_path = pathlib.Path.home().joinpath('.orchid', 'python_api.yaml')
-    if file_config_path.exists():
-        with file_config_path.open('r') as in_stream:
-            file = yaml.full_load(in_stream)
-    _logger.debug(f'file configuration={file}')
-    return file
-
-
-def get_configuration() -> Dict[str, Dict[str, Any]]:
-    """
-    Calculate the configuration for the Python API.
-
-        Returns: The Python API configuration.
-    """
-
-    fallback_configuration = get_fallback_configuration()
-    file_configuration = get_file_configuration()
-    env_configuration = get_environment_configuration()
-
-    configuration_dict = merge_configurations(fallback_configuration, file_configuration, env_configuration)
-    if not configuration_dict.get('orchid') or (configuration_dict.get('orchid') and not configuration_dict['orchid'].get('root')):
-        raise ConfigurationError("You must create an environment variable ORCHID_ROOT or a config file to set up the path to the PythonApiLibs folder since it's not in the default location")
-
-    _logger.debug(f'result configuration={configuration_dict}')
-    return configuration_dict
-
-
-def merge_configurations(fallback_configuration: Dict[str, Dict[str, str]], file_configuration: Dict[str, Dict[str, Any]], env_configuration: Dict[str, Dict[str, str]]) -> Dict[str, Dict[str, Any]]:
-    # The rules for merging these configurations is not the same as a simple dictionary. The rules are:
-    # - If two different configurations share a top-level key, merge the second level dictionaries.
-    # - Then merge the distinct top-level keys.
-    distinct_top_level_keys = set(toolz.concat([fallback_configuration.keys(),
-                                                file_configuration.keys(),
-                                                env_configuration.keys()]))
-    result = {}
-    for top_level_key in distinct_top_level_keys:
-        fallback_child_configuration = fallback_configuration.get(top_level_key, {})
-        file_child_configuration = file_configuration.get(top_level_key, {})
-        env_child_configuration = env_configuration.get(top_level_key, {})
-        child_configuration = toolz.merge(fallback_child_configuration,
-                                          file_child_configuration,
-                                          env_child_configuration)
-        result[top_level_key] = child_configuration
-    return result
-
-
-def training_data_path() -> pathlib.Path:
-    """
-    Returns the path of the directory containing the Orchid training data.
-
-    Returns:
-        The Orchid training data path.
-
-    Raises:
-        This function raises KeyError if the training directory path is not available from the package
-        configuration.
-    """
-    result = pathlib.Path(toolz.get_in(['orchid', 'training_data'], get_configuration()))
-    return result

orchid/convert.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.
-#
-
-from typing import Union
-
-import toolz.curried as toolz
-
-from orchid import (
-    measurement as om,
-    unit_system as units,
-)
-
-
-@toolz.curry
-def to_unit(target_unit: Union[units.UsOilfield, units.Metric], source_measurement: om.Quantity):
-    """
-    Convert a `Measurement` instance to the same measurement in `target_unit`.
-
-    The order of arguments allows easier conversion of a sequence of `Measurement` instances (with the same
-    unit) to another unit. For example, if client code wished to convert a sequence of force measurements from
-    US oilfield units to metric units (that is, pound-force to Newtons). Code to perform this conversion might
-    be similar to the following:
-
-    > make_metric_force = to_unit(units.Metric.FORCE)
-    > metric_force_measurements = [make_metric_force(f) for f in us_oilfield_force_measurements]
-    > # alternatively,
-    > # metric_force_measurements = toolz.map(make_metric_force, us_oilfield_force_measurements)
-
-    Args:
-        source_measurement: The Measurement instance to convert.
-        target_unit: The units to which I convert `source_measurement`.
-    """
-    return source_measurement.to(target_unit.value.unit)

orchid/core.py

@@ -1,149 +0,0 @@
-# -*- coding: utf-8 -*-
-
-#  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 typing import Optional
-
-import deal
-import option
-
-from orchid.project import Project
-from orchid.project_store import ProjectStore
-
-# To support doctests only
-import shutil
-
-import orchid
-
-
-# TODO: change `ifrac_pathname` to be `str` or `pathlib.Path`
-@deal.pre(lambda ifrac_pathname: len(ifrac_pathname.strip()) != 0)
-@deal.pre(lambda ifrac_pathname: ifrac_pathname is not None)
-def load_project(ifrac_pathname: str) -> Project:
-    """
-    Return the project for the specified `.ifrac` file.
-
-    Args:
-        ifrac_pathname: The path identifying the data file of the project of interest.
-
-    Returns:
-        The project of interest.
-
-    Examples:
-        >>> load_path = orchid.training_data_path().joinpath('frankNstein_Bakken_UTM13_FEET.ifrac')
-        >>> loaded_project = orchid.load_project(str(load_path))
-        >>> loaded_project.name
-        'frankNstein_Bakken_UTM13_FEET'
-    """
-    loader = ProjectStore(ifrac_pathname.strip())
-    result = Project(loader)
-    return result
-
-
-# TODO: change `ifrac_pathname` to be `str` or `pathlib.Path`
-@deal.pre(lambda project, _: project is not None)
-@deal.pre(lambda _, ifrac_pathname: ifrac_pathname is not None)
-@deal.pre(lambda _, ifrac_pathname: len(ifrac_pathname) != 0)
-@deal.pre(lambda _, ifrac_pathname: len(ifrac_pathname.strip()) != 0)
-def save_project(project: Project, ifrac_pathname: str) -> None:
-    """
-    Return the project for the specified `.ifrac` file.
-
-    Args:
-        ifrac_pathname: The path identifying the data file of the project of interest.
-        project: The project of interest.
-
-    Examples:
-        >>> # Test saving changed project
-        >>> load_path = orchid.training_data_path().joinpath('frankNstein_Bakken_UTM13_FEET.ifrac')
-        >>> loaded_project = orchid.load_project(str(load_path))
-        >>> save_path = load_path.with_name(f'salvus{load_path.suffix}')
-        >>> orchid.save_project(loaded_project, str(save_path))
-        >>> save_path.exists()
-        True
-        >>> save_path.unlink()
-    """
-
-    store = ProjectStore(ifrac_pathname.strip())
-    store.save_project(project)
-
-
-# TODO: change `ifrac_pathname` to be `str` or `pathlib.Path`
-@deal.pre(lambda _: _.project is not None)
-@deal.pre(lambda _: _.project is not None)
-@deal.pre(lambda _: _.source_pathname is not None)
-@deal.pre(lambda _: len(_.source_pathname) != 0)
-@deal.pre(lambda _: len(_.source_pathname.strip()) != 0)
-@deal.pre(lambda _: (_.maybe_target_pathname is None or
-                     (_.maybe_target_pathname is not None and len(_.maybe_target_pathname) != 0)))
-@deal.pre(lambda _: (_.maybe_target_pathname is None or
-                     (_.maybe_target_pathname is not None and len(_.maybe_target_pathname.strip()) != 0)))
-def optimized_but_possibly_unsafe_save(project: Project, source_pathname: str,
-                                       maybe_target_pathname: Optional[str] = None):
-    """
-    Saves `project`, optionally to `maybe_to_pathname` is an optimized, but possibly "unsafe" manner.
-
-    If `maybe_to_pathname` is supplied and is not `None`, it must be a string representing a valid pathname. If a file
-    with that pathname already exists, it will be overwritten (unless it is the same path as `source_pathname`)
-
-    This method is unsafe because it only writes some data from `project`; the remainder of the data is simply
-    (bulk) copied from the `.ifrac` file, `source_pathname`.
-
-    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.
-        source_pathname: The pathname of the `.ifrac` file from which `project` was loaded.
-        maybe_target_pathname: The optional pathname of the `.ifrac` file in which to store `project`.
-
-    Examples:
-        >>> # Test optimized but possibly unsafe save of project
-        >>> load_path = orchid.training_data_path().joinpath('Project_frankNstein_Permian_UTM13_FEET.ifrac')
-        >>> loaded_project = orchid.load_project(str(load_path))
-        >>> save_path = load_path.with_name(f'salva intuta{load_path.suffix}')
-        >>> orchid.optimized_but_possibly_unsafe_save(loaded_project, str(load_path), str(save_path))
-        >>> save_path.exists()
-        True
-        >>> save_path.unlink()
-        >>> # Test optimized but possibly unsafe save of project in loaded location
-        >>> source_path = orchid.training_data_path().joinpath('Project_frankNstein_Permian_UTM13_FEET.ifrac')
-        >>> load_path = source_path.with_name(f'idem salvum filum{source_path.suffix}')
-        >>> # ignore returned result for doctest
-        >>> _to_path = shutil.copyfile(str(source_path), str(load_path))
-        >>> loaded_project = orchid.load_project(str(load_path))
-        >>> orchid.optimized_but_possibly_unsafe_save(loaded_project, str(load_path))
-        >>> load_path.exists()
-        True
-        >>> load_path.unlink()
-
-    """
-    store = ProjectStore(source_pathname.strip())
-    store.optimized_but_possibly_unsafe_save(project, option.maybe(maybe_target_pathname))

orchid/dom_project_object.py

@@ -1,28 +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 option
-
-from orchid import dot_net_dom_access as dna
-
-
-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 DomProjectObject(dna.IdentifiedDotNetAdapter):
-    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)

orchid/dot_net.py

@@ -1,68 +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 os
-import pathlib
-
-import orchid.configuration
-import orchid.script_adapter_context as sac
-
-import toolz.curried as toolz
-
-from pythonnet import load
-load('coreclr')
-
-# noinspection PyPackageRequirements
-import clr
-
-
-def add_orchid_assemblies() -> None:
-    """
-    Add references to the Orchid assemblies needed by the Python API.
-
-    Although not all modules in the `orchid` package need .NET types from all the available Orchid assemblies,
-    I believe the additional cost of adding those references is far less than the cost of maintaining the
-    copy-paste, boilerplate code that results without this common function.
-    :return:
-    """
-    clr.AddReference('Orchid.Common')
-    clr.AddReference('Orchid.FractureDiagnostics')
-    clr.AddReference('Orchid.FractureDiagnostics.Factories')
-    clr.AddReference('UnitsNet')
-    clr.AddReference('System.Collections')
-    return None
-
-
-def app_settings_path() -> str:
-    """
-    Return the pathname of the `appSettings.json` file needed by the `SDKFacade` assembly.
-
-    :return: The required pathname.
-    """
-    result = os.fspath(pathlib.Path(toolz.get_in(['orchid', 'root'], orchid.configuration.get_configuration())).joinpath('appSettings.json'))
-    return result
-
-
-def prepare_imports() -> None:
-    # This function call must occur *after*
-    # - Importing clr
-    # - Adding a reference to `Orchid.FractureDiagnostics.SDKFacade`
-    # - Importing ScriptAdapter from `Orchid.FractureDiagnostics.SDKFacade`
-    # - The call to `append_orchid_assemblies_directory_path`
-    with sac.ScriptAdapterContext():
-        orchid.dot_net.add_orchid_assemblies()

orchid/dot_net_disposable.py

@@ -1,64 +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.
-#
-"""Wrapper function to help deal with IDisposable classes.
-
-This implementation is based on code in the discussion of
-[Python.NET issue 79](https://github.com/pythonnet/pythonnet/issues/79#issuecomment-187107566).
-"""
-
-from inspect import isclass, isfunction
-from contextlib import contextmanager
-
-__all__ = ['disposable']
-
-"""Contextmanager wrapper around IDisposables."""
-
-
-@contextmanager
-def disposable(obj_or_class, *args, **kwargs):
-    """
-    Contextmanager wrapper around IDisposables.
-
-    Example:
-
-    >>> with disposable(dbConnection):
-    >>>     blah()
-
-    Args:
-        obj_or_class: The .NET object or class with a `Dispose` method.
-        *args: Positional arguments needed to manage the context managed by `__enter__/__exit__`.
-        **kwargs: Keyword arguments needed to manage the context managed by `__exit__/__exit_-`.
-
-    Returns:
-        The instance of the object or class implementing `IDispose`.
-    """
-
-    if isclass(obj_or_class) or isfunction(obj_or_class):
-        obj = obj_or_class(*args, **kwargs)
-    else:
-        obj = obj_or_class
-
-    if hasattr(obj, '__enter__') and hasattr(obj, '__exit__'):
-        # Already a contextmanager, skip
-        return obj
-
-    if not hasattr(obj, 'Dispose') or not callable(obj.Dispose):
-        # Likely not IDisposable, currently isinstance doesn't work for
-        # interfaces, so we have to check that in this explicit way
-        return obj
-
-    try:
-        yield obj
-    finally:
-        obj.Dispose()