honeybee-core 1.64.12__py3-none-any.whl

honeybee/config.py

@@ -0,0 +1,347 @@
+"""Honeybee configurations.
+
+Import this into every module where access configurations are needed.
+
+Usage:
+
+.. code-block:: python
+
+    from honeybee.config import folders
+    print(folders.python_exe_path)
+    print(folders.default_simulation_folder)
+    folders.default_simulation_folder = "C:/my_sim_folder"
+"""
+import ladybug.config as lb_config
+
+import os
+import platform
+import sys
+import subprocess
+import json
+import tempfile
+
+
+class Folders(object):
+    """Honeybee folders.
+
+    Args:
+        config_file: The path to the config.json file from which folders are loaded.
+            If None, the config.json module included in this package will be used.
+            Default: None.
+        mute: If False, the paths to the various folders will be printed as they
+            are found. If True, no printing will occur upon initialization of this
+            class. Default: True.
+
+    Properties:
+        * default_simulation_folder
+        * honeybee_core_version
+        * honeybee_core_version_str
+        * honeybee_schema_version
+        * honeybee_schema_version_str
+        * python_package_path
+        * python_scripts_path
+        * python_exe_path
+        * python_version
+        * python_version_str
+        * default_standards_folder
+        * config_file
+        * mute
+    """
+
+    def __init__(self, config_file=None, mute=True):
+        # set the mute value
+        self.mute = bool(mute)
+
+        # load paths from the config JSON file
+        self.config_file = config_file
+
+        # set python version to only be retrieved if requested
+        self._python_version = None
+        self._python_version_str = None
+
+        # search for the version of honeybee-core and honeybee-schema
+        self._honeybee_core_version = self._find_honeybee_core_version()
+        self._honeybee_schema_version = self._find_honeybee_schema_version()
+
+    @property
+    def default_simulation_folder(self):
+        """Get or set the path to the default simulation folder."""
+        return self._default_simulation_folder
+
+    @default_simulation_folder.setter
+    def default_simulation_folder(self, path):
+        if not path:  # check the default location for simulations
+            path = self._find_default_simulation_folder()
+
+        self._default_simulation_folder = path
+
+        if not self.mute and self._default_simulation_folder:
+            print('Path to the default simulation folder is set to: '
+                  '{}'.format(self._default_simulation_folder))
+
+    @property
+    def honeybee_core_version(self):
+        """Get a tuple for the installed version of honeybee-core (eg. (1, 47, 26)).
+
+        This will be None if the version could not be sensed (it was not installed
+        via pip).
+        """
+        return self._honeybee_core_version
+
+    @property
+    def honeybee_core_version_str(self):
+        """Get a string for the installed version of honeybee-core (eg. "1.47.26").
+
+        This will be None if the version could not be sensed.
+        """
+        if self._honeybee_core_version is not None:
+            return '.'.join([str(item) for item in self._honeybee_core_version])
+        return None
+
+    @property
+    def honeybee_schema_version(self):
+        """Get a tuple for the installed version of honeybee-schema (eg. (1, 35, 0)).
+
+        This will be None if the version could not be sensed (it was not installed
+        via pip) or if no honeybee-schema installation was found next to the
+        honeybee-core installation.
+        """
+        return self._honeybee_schema_version
+
+    @property
+    def honeybee_schema_version_str(self):
+        """Get a string for the installed version of honeybee-schema (eg. "1.35.0").
+
+        This will be None if the version could not be sensed.
+        """
+        if self._honeybee_schema_version is not None:
+            return '.'.join([str(item) for item in self._honeybee_schema_version])
+        return None
+
+    @property
+    def python_package_path(self):
+        """Get the path to where this Python package is installed."""
+        # check the ladybug_tools folder for a Python installation
+        py_pack = None
+        lb_install = lb_config.folders.ladybug_tools_folder
+        if os.path.isdir(lb_install):
+            if os.name == 'nt':
+                py_pack = os.path.join(lb_install, 'python', 'Lib', 'site-packages')
+            elif platform.system() == 'Darwin':  # on mac, python version is in path
+                py_pack = os.path.join(
+                    lb_install, 'python', 'lib', 'python3.7', 'site-packages')
+        if py_pack is not None and os.path.isdir(py_pack):
+            return py_pack
+        return os.path.split(os.path.dirname(__file__))[0]  # we're on some other cPython
+
+    @property
+    def python_scripts_path(self):
+        """Get the path to where Python CLI executable files are installed.
+
+        This can be used to call command line interface (CLI) executable files
+        directly (instead of using their usual entry points).
+        """
+        # check the ladybug_tools folder for a Python installation
+        lb_install = lb_config.folders.ladybug_tools_folder
+        if os.path.isdir(lb_install):
+            py_scripts = os.path.join(lb_install, 'python', 'Scripts') \
+                if os.name == 'nt' else \
+                os.path.join(lb_install, 'python', 'bin')
+            if os.path.isdir(py_scripts):
+                return py_scripts
+        sys_dir = os.path.dirname(sys.executable)  # assume we are on some other cPython
+        return os.path.join(sys_dir, 'Scripts') if os.name == 'nt' else sys_dir
+
+    @property
+    def python_exe_path(self):
+        """Get the path to the Python executable to be used for Ladybug Tools CLI calls.
+
+        If a version of Python is found within the ladybug_tools installation folder,
+        this will be the path to that version of Python. Otherwise, it will be
+        assumed that this is package is installed in cPython outside of the ladybug_tools
+        folder and the sys.executable will be returned.
+        """
+        # check the ladybug_tools folder for a Python installation
+        lb_install = lb_config.folders.ladybug_tools_folder
+        if os.path.isdir(lb_install):
+            py_exe_file = os.path.join(lb_install, 'python', 'python.exe') \
+                if os.name == 'nt' else \
+                os.path.join(lb_install, 'python', 'bin', 'python3')
+            if os.path.isfile(py_exe_file):
+                return py_exe_file
+        return sys.executable  # assume we are on some other cPython
+
+    @property
+    def python_version(self):
+        """Get a tuple for the version of python (eg. (3, 8, 2)).
+
+        This will be None if the version could not be sensed or if no Python
+        installation was found.
+        """
+        if self._python_version_str is None and self.python_exe_path:
+            self._python_version_from_cli()
+        return self._python_version
+
+    @property
+    def python_version_str(self):
+        """Get text for the full version of python (eg."3.8.2").
+
+        This will be None if the version could not be sensed or if no Python
+        installation was found.
+        """
+        if self._python_version_str is None and self.python_exe_path:
+            self._python_version_from_cli()
+        return self._python_version_str
+
+    @property
+    def default_standards_folder(self):
+        """Get or set the path to the default standards library used by extensions.
+        """
+        return self._default_standards_folder
+
+    @default_standards_folder.setter
+    def default_standards_folder(self, path):
+        if not path:  # check the default locations of the template library
+            path = self._find_default_standards_folder()
+
+        # set the default_standards_folder
+        self._default_standards_folder = path
+        if path and not self.mute:
+            print('Path to the default_standards_folder is set to: '
+                  '{}'.format(self._default_standards_folder))
+
+    @property
+    def config_file(self):
+        """Get or set the path to the config.json file from which folders are loaded.
+
+        Setting this to None will result in using the config.json module included
+        in this package.
+        """
+        return self._config_file
+
+    @config_file.setter
+    def config_file(self, cfg):
+        if cfg is None:
+            cfg = os.path.join(os.path.dirname(__file__), 'config.json')
+        self._load_from_file(cfg)
+        self._config_file = cfg
+
+    def _load_from_file(self, file_path):
+        """Set all of the the properties of this object from a config JSON file.
+
+        Args:
+            file_path: Path to a JSON file containing the file paths. A sample of this
+                JSON is the config.json file within this package.
+        """
+        # check the default file path
+        assert os.path.isfile(file_path), \
+            ValueError('No file found at {}'.format(file_path))
+
+        # set the default paths to be all blank
+        default_path = {
+            "default_simulation_folder": r'',
+            "default_standards_folder": r''
+        }
+
+        with open(file_path, 'r') as cfg:
+            try:
+                paths = json.load(cfg)
+            except Exception as e:
+                print('Failed to load paths from {}.\nThey will be set to defaults '
+                      'instead\n{}'.format(file_path, e))
+            else:
+                for key, p in paths.items():
+                    if not key.startswith('__') and p.strip():
+                        default_path[key] = p.strip()
+
+        # set paths for the default_simulation_folder
+        self.default_simulation_folder = default_path["default_simulation_folder"]
+        self.default_standards_folder = default_path["default_standards_folder"]
+
+    def _python_version_from_cli(self):
+        """Set this object's Python version by making a call to a Python command."""
+        cmds = [self.python_exe_path, '--version']
+        use_shell = True if os.name == 'nt' else False
+        process = subprocess.Popen(cmds, stdout=subprocess.PIPE, shell=use_shell)
+        stdout = process.communicate()
+        base_str = str(stdout[0]).replace("b'", '').replace(r"\r\n'", '')
+        self._python_version_str = base_str.split(' ')[-1]
+        try:
+            self._python_version = \
+                tuple(int(i) for i in self._python_version_str.split('.'))
+        except Exception:
+            pass  # failed to parse the version into values
+
+    @staticmethod
+    def _find_default_simulation_folder():
+        """Find the the default simulation folder in its usual location.
+
+        An attempt will be made to create the directory if it does not already exist.
+        """
+        home_folder = os.getenv('HOME') or os.path.expanduser('~')
+        if not os.access(home_folder, os.W_OK):
+            home_folder = tempfile.gettempdir()
+        sim_folder = os.path.join(home_folder, 'simulation')
+        if not os.path.isdir(sim_folder):
+            try:
+                os.makedirs(sim_folder)
+            except OSError as e:
+                if e.errno != 17:  # avoid race conditions between multiple tasks
+                    raise OSError('Failed to create default simulation '
+                                  'folder: %s\n%s' % (sim_folder, e))
+        return sim_folder
+
+    @staticmethod
+    def _find_default_standards_folder():
+        """Find the user standards library in its default location.
+
+        The %AppData%/ladybug_tools/standards folder will be checked first, which
+        can contain libraries that are not overwritten with the update of the
+        honeybee_energy package. If this is not found, the ladybug_tools/resources/
+        standards/honeybee_standards folder will be checked next. If no such folder
+        is found, this None will be returned.
+        """
+        # first check if there's a user-defined folder in AppData
+        app_folder = os.getenv('APPDATA')
+        if app_folder is not None:
+            lib_folder = os.path.join(app_folder, 'ladybug_tools', 'standards')
+            if os.path.isdir(lib_folder):
+                return lib_folder
+
+        # then check the ladybug_tools installation folder were permanent lib is
+        lb_install = lb_config.folders.ladybug_tools_folder
+        if os.path.isdir(lb_install):
+            lib_folder = os.path.join(
+                lb_install, 'resources', 'standards', 'honeybee_standards')
+            if os.path.isdir(lib_folder):
+                return lib_folder
+
+        # default to None if nothing was found
+        return None
+
+    def _find_honeybee_core_version(self):
+        """Get a tuple of 3 integers for the version of honeybee_core if installed."""
+        return self._find_package_version('honeybee_core')
+
+    def _find_honeybee_schema_version(self):
+        """Get a tuple of 3 integers for the version of honeybee_schema if installed."""
+        return self._find_package_version('honeybee_schema')
+
+    def _find_package_version(self, package_name):
+        """Get a tuple of 3 integers for the version of a package."""
+        hb_info_folder = None
+        for item in os.listdir(self.python_package_path):
+            if item.startswith(package_name + '-') and item.endswith('.dist-info'):
+                if os.path.isdir(os.path.join(self.python_package_path, item)):
+                    hb_info_folder = item
+                    break
+        if hb_info_folder is not None:
+            hb_info_folder = hb_info_folder.replace('.dist-info', '')
+            ver = ''.join(s for s in hb_info_folder if (s.isdigit() or s == '.'))
+            if ver:  # version was found in the file path name
+                return tuple(int(d) for d in ver.split('.'))
+        return None
+
+
+"""Object possesing all key folders within the configuration."""
+folders = Folders()

honeybee/dictutil.py

@@ -0,0 +1,54 @@
+# coding=utf-8
+"""Utilities to convert any dictionary to Python objects.
+
+Note that importing this module will import almost all modules within the
+library in order to be able to re-serialize almost any dictionary produced
+from the library.
+"""
+from honeybee.model import Model
+from honeybee.room import Room
+from honeybee.face import Face
+from honeybee.aperture import Aperture
+from honeybee.door import Door
+from honeybee.shade import Shade
+import honeybee.boundarycondition as hbc
+
+
+def dict_to_object(honeybee_dict, raise_exception=True):
+    """Re-serialize a dictionary of almost any object within honeybee.
+
+    This includes any Model, Room, Face, Aperture, Door, Shade, or boundary
+    condition object.
+
+    Args:
+        honeybee_dict: A dictionary of any Honeybee object. Note
+            that this should be a non-abridged dictionary to be valid.
+        raise_exception: Boolean to note whether an exception should be raised
+            if the object is not identified as a part of honeybee.
+            Default: True.
+
+    Returns:
+        A Python object derived from the input honeybee_dict.
+    """
+    try:  # get the type key from the dictionary
+        obj_type = honeybee_dict['type']
+    except KeyError:
+        raise ValueError('Honeybee dictionary lacks required "type" key.')
+
+    if obj_type == 'Model':
+        return Model.from_dict(honeybee_dict)
+    elif obj_type == 'Room':
+        return Room.from_dict(honeybee_dict)
+    elif obj_type == 'Face':
+        return Face.from_dict(honeybee_dict)
+    elif obj_type == 'Aperture':
+        return Aperture.from_dict(honeybee_dict)
+    elif obj_type == 'Door':
+        return Door.from_dict(honeybee_dict)
+    elif obj_type == 'Shade':
+        return Shade.from_dict(honeybee_dict)
+    elif hasattr(hbc, obj_type):
+        bc_class = getattr(hbc, obj_type)
+        return bc_class.from_dict(honeybee_dict)
+    elif raise_exception:
+        raise ValueError('{} is not a recognized honeybee object'.format(obj_type))