fairyfly-therm 0.3.1__py3-none-any.whl

fairyfly_therm/__init__.py

@@ -0,0 +1,8 @@
+"""fairyfly-radiance library."""
+
+from fairyfly.logutil import get_logger
+
+# use the same logger settings across fairyfly extensions
+# this does NOT mean that the logs will be written to the same file but they will have
+# the same formatting, level, etc.
+logger = get_logger(name=__name__)

fairyfly_therm/__main__.py

@@ -0,0 +1,4 @@
+from fairyfly_therm.cli import therm
+
+if __name__ == '__main__':
+    therm()

fairyfly_therm/cli/__init__.py

@@ -0,0 +1,47 @@
+"""fairyfly-therm commands which will be added to fairyfly command line interface."""
+import click
+import sys
+import logging
+import json
+
+from fairyfly.cli import main
+from ..config import folders
+from .setconfig import set_config
+
+_logger = logging.getLogger(__name__)
+
+
+# command group for all therm extension commands.
+@click.group(help='fairyfly therm commands.')
+@click.version_option()
+def therm():
+    pass
+
+
+@therm.command('config')
+@click.option('--output-file', help='Optional file to output the JSON string of '
+              'the config object. By default, it will be printed out to stdout',
+              type=click.File('w'), default='-', show_default=True)
+def config(output_file):
+    """Get a JSON object with all configuration information"""
+    try:
+        config_dict = {
+            'therm_path': folders.therm_path,
+            'therm_version': folders.therm_version_str,
+            'lbnl_data_path': folders.lbnl_data_path,
+            'therm_settings_path': folders.therm_settings_path,
+            'therm_lib_path': folders.therm_lib_path
+        }
+        output_file.write(json.dumps(config_dict, indent=4))
+    except Exception as e:
+        _logger.exception('Failed to retrieve configurations.\n{}'.format(e))
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+# add sub-commands to therm
+therm.add_command(set_config, name='set-config')
+
+# add therm sub-commands to fairyfly CLI
+main.add_command(therm)

fairyfly_therm/cli/setconfig.py

@@ -0,0 +1,75 @@
+"""Commands to set fairyfly-therm configurations."""
+import click
+import sys
+import logging
+import json
+
+from fairyfly_therm.config import folders
+
+_logger = logging.getLogger(__name__)
+
+
+@click.group(help='Commands to set fairyfly-therm configurations.')
+def set_config():
+    pass
+
+
+@set_config.command('therm-path')
+@click.argument('folder-path', required=False, type=click.Path(
+    exists=True, file_okay=False, dir_okay=True, resolve_path=True))
+def therm_path(folder_path):
+    """Set the therm-path configuration variable.
+
+    \b
+    Args:
+        folder_path: Path to a folder to be set as the therm-path.
+            If unspecified, the therm-path will be set back to the default.
+    """
+    _set_config_variable(folder_path, 'therm_path')
+
+
+@set_config.command('lbnl-data-path')
+@click.argument('folder-path', required=False, type=click.Path(
+    exists=True, file_okay=False, dir_okay=True, resolve_path=True))
+def lbnl_data_path(folder_path):
+    """Set the lbnl-data-path configuration variable.
+
+    \b
+    Args:
+        folder_path: Path to a folder to be set as the lbnl-data-path.
+            If unspecified, the lbnl-data-path will be set back to the default.
+    """
+    _set_config_variable(folder_path, 'lbnl_data_path')
+
+
+@set_config.command('therm-lib-path')
+@click.argument('folder-path', required=False, type=click.Path(
+    exists=True, file_okay=False, dir_okay=True, resolve_path=True))
+def therm_lib_path(folder_path):
+    """Set the therm-lib-path configuration variable.
+
+    \b
+    Args:
+        folder_path: Path to a folder to be set as the therm-lib-path.
+            If unspecified, the therm-lib-path will be set back to the default.
+    """
+    _set_config_variable(folder_path, 'therm_lib_path')
+
+
+def _set_config_variable(folder_path, variable_name):
+    var_cli_name = variable_name.replace('_', '-')
+    try:
+        config_file = folders.config_file
+        with open(config_file) as inf:
+            data = json.load(inf)
+        data[variable_name] = folder_path if folder_path is not None else ''
+        with open(config_file, 'w') as fp:
+            json.dump(data, fp, indent=4)
+        msg_end = 'reset to default' if folder_path is None \
+            else 'set to: {}'.format(folder_path)
+        print('{} successfully {}.'.format(var_cli_name, msg_end))
+    except Exception as e:
+        _logger.exception('Failed to set {}.\n{}'.format(var_cli_name, e))
+        sys.exit(1)
+    else:
+        sys.exit(0)

fairyfly_therm/condition/__init__.py

@@ -0,0 +1 @@
+"""fairyfly-therm conditions."""

fairyfly_therm/condition/_base.py

@@ -0,0 +1,167 @@
+# coding=utf-8
+"""Base therm condition."""
+from __future__ import division
+import uuid
+import random
+
+from ladybug.color import Color
+from fairyfly._lockable import lockable
+from fairyfly.typing import valid_uuid
+
+
+@lockable
+class _ThermConditionBase(object):
+    """Base therm condition.
+
+    Args:
+        identifier: Text string for a unique Condition ID. Must be < 100 characters
+            and not contain any thermPlus special characters. This will be used to
+            identify the object across a model and in the exported IDF.
+
+    Properties:
+        * identifier
+        * display_name
+        * color
+        * protected
+        * project_tag
+        * user_data
+    """
+    __slots__ = ('_identifier', '_display_name', '_color', '_protected', '_project_tag',
+                 '_user_data', '_locked')
+
+    def __init__(self, identifier):
+        """Initialize therm condition base."""
+        self._locked = False
+        self.identifier = identifier
+        self._display_name = None
+        self.color = None
+        self.protected = False
+        self.project_tag = None
+        self._user_data = None
+
+    @property
+    def identifier(self):
+        """Get or set a text string for the unique object identifier.
+
+        This must be a UUID in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+        and it remains constant as the object is mutated, copied, and
+        serialized to different formats (eg. therm XML). As such, this
+        property is used to reference the object across a Model.
+        """
+        return self._identifier
+
+    @identifier.setter
+    def identifier(self, value):
+        if value is None:
+            self._identifier = str(uuid.uuid4())
+        else:
+            self._identifier = valid_uuid(value, 'therm condition identifier')
+
+    @property
+    def display_name(self):
+        """Get or set a string for the object name without any character restrictions.
+
+        If not set, this will be equal to the identifier.
+        """
+        if self._display_name is None:
+            return self._identifier
+        return self._display_name
+
+    @display_name.setter
+    def display_name(self, value):
+        if value is not None:
+            try:
+                value = str(value)
+            except UnicodeEncodeError:  # Python 2 machine lacking the character set
+                pass  # keep it as unicode
+        self._display_name = value
+
+    @property
+    def color(self):
+        """Get or set an optional color for the condition as it displays in THERM.
+
+        This will always be a Ladybug Color object when getting this property
+        but the setter supports specifying hex codes. If unspecified, a radom
+        color will automatically be assigned.
+        """
+        return self._color
+
+    @color.setter
+    def color(self, value):
+        if value is None:
+            self._color = Color(
+                random.randint(0, 255),
+                random.randint(0, 255),
+                random.randint(0, 255)
+            )
+        elif isinstance(value, str):
+            value = value.replace('0x', '')
+            self._color = Color.from_hex(value)
+        else:
+            assert isinstance(value, Color), 'Expected ladybug Color object for ' \
+                'condition color. Got {}.'.format(type(value))
+            self._color = value
+
+    @property
+    def protected(self):
+        """Get or set a boolean for whether the condition is protected in THERM."""
+        return self._protected
+
+    @protected.setter
+    def protected(self, value):
+        try:
+            self._protected = bool(value)
+        except TypeError:
+            raise TypeError(
+                'Expected boolean for Condition.protected. Got {}.'.format(value))
+
+    @property
+    def project_tag(self):
+        """Get or set a string for the condition's project name."""
+        return self._project_tag
+
+    @project_tag.setter
+    def project_tag(self, value):
+        if value is not None:
+            try:
+                value = str(value)
+            except UnicodeEncodeError:  # Python 2 machine lacking the character set
+                pass  # keep it as unicode
+        self._project_tag = value
+
+    @property
+    def user_data(self):
+        """Get or set an optional dictionary for additional meta data for this object.
+
+        This will be None until it has been set. All keys and values of this
+        dictionary should be of a standard Python type to ensure correct
+        serialization of the object to/from JSON (eg. str, float, int, list, dict)
+        """
+        if self._user_data is not None:
+            return self._user_data
+
+    @user_data.setter
+    def user_data(self, value):
+        if value is not None:
+            assert isinstance(value, dict), 'Expected dictionary for fairyfly_therm' \
+                'object user_data. Got {}.'.format(type(value))
+        self._user_data = value
+
+    def duplicate(self):
+        """Get a copy of this construction."""
+        return self.__copy__()
+
+    def __copy__(self):
+        new_obj = self.__class__(self.identifier)
+        new_obj._display_name = self._display_name
+        new_obj._color = self._color
+        new_obj._project_tag = self._project_tag
+        new_obj._user_data = None if self._user_data is None else self._user_data.copy()
+        return new_obj
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+    def __repr__(self):
+        return 'Base THERM Condition:\n{}'.format(self.display_name)