honeybee-core 1.64.12__py3-none-any.whl

honeybee/cli/setconfig.py

@@ -0,0 +1,43 @@
+"""Commands to set honeybee-core configurations."""
+import click
+import sys
+import logging
+import json
+
+from honeybee.config import folders
+
+_logger = logging.getLogger(__name__)
+
+
+@click.group(help='Commands to set honeybee-core configurations.')
+def set_config():
+    pass
+
+
+@set_config.command('default-simulation-folder')
+@click.argument('folder-path', required=False, type=click.Path(
+    exists=True, file_okay=False, dir_okay=True, resolve_path=True))
+def default_simulation_folder(folder_path):
+    """Set the default-simulation-folder configuration variable.
+
+    \b
+    Args:
+        folder_path: Path to a folder to be set as the default-simulation-folder.
+            If unspecified, the default-simulation-folder will be set back to
+            the default.
+    """
+    try:
+        config_file = folders.config_file
+        with open(config_file) as inf:
+            data = json.load(inf)
+        data['default_simulation_folder'] = 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('default-simulation-folder successfully {}.'.format(msg_end))
+    except Exception as e:
+        _logger.exception('Failed to set default-simulation-folder.\n{}'.format(e))
+        sys.exit(1)
+    else:
+        sys.exit(0)

honeybee/cli/validate.py

@@ -0,0 +1,224 @@
+"""honeybee validation commands."""
+import sys
+import logging
+import click
+
+from ladybug.commandutil import process_content_to_output
+from honeybee.model import Model
+
+_logger = logging.getLogger(__name__)
+
+
+@click.group(help='Commands for validating Honeybee objects.')
+def validate():
+    pass
+
+
+@validate.command('model')
+@click.argument('model-file', type=click.Path(
+    exists=True, file_okay=True, dir_okay=False, resolve_path=True))
+@click.option(
+    '--extension', '-e', help='Text for the name of the extension to be checked. '
+    'The value input is case-insensitive such that "radiance" and "Radiance" will '
+    'both result in the model being checked for validity with honeybee-radiance. '
+    'This value can also be set to "Generic" in order to run checks for all installed '
+    'extensions. Using "Generic" will run all except the most limiting of checks '
+    '(eg. the DOE2 lack of support for courtyards) with the goal of producing a model '
+    'that can be exported to multiple engines (albeit with a little extra '
+    'postprocessing for particularly limited engines). Some common honeybee extension '
+    'names that can be input here include: Radiance, EnergyPlus, DOE2, IES, IDAICE',
+    type=str, default='Generic', show_default=True)
+@click.option(
+    '--plain-text/--json', ' /-j', help='Flag to note whether the output validation '
+    'report should be formatted as a JSON object instead of plain text. If set to JSON, '
+    'the output object will contain several attributes. The "honeybee_core" and '
+    '"honeybee_schema" attributes will note the versions of these libraries used in '
+    'the validation process. An attribute called "fatal_error" is a text string '
+    'containing an exception if the Model failed to serialize and will be an empty '
+    'string if serialization was successful. An attribute called "errors" will '
+    'contain a list of JSON objects for each invalid issue found in the model. A '
+    'boolean attribute called "valid" will note whether the Model is valid or not.',
+    default=True, show_default=True)
+@click.option(
+    '--room-overlaps', 'room_overlaps', flag_value='True',
+    help='Deprecated flag used to check room collisions. '
+    'Use `honeybee validate room-collisions` instead.')
+@click.option(
+    '--output-file', '-f', help='Optional file to output the full report '
+    'of the validation. By default it will be printed out to stdout',
+    type=click.File('w'), default='-')
+def validate_model_cli(model_file, extension, plain_text, room_overlaps, output_file):
+    """Validate all properties of a Model file against Honeybee schema.
+
+    This includes checking basic compliance with the 5 rules of honeybee geometry
+    as well as checks for all extension attributes. The 5 rules of honeybee geometry
+    are as follows.
+
+    1. All Face3Ds must be planar to within the model tolerance.
+
+    2. All Face3Ds must NOT be self-intersecting (like a bowtie shape)
+
+    3. All children sub-faces (Apertures and Doors) must be co-planar with
+        their parent Face and lie completely within its boundary.
+
+    4. All adjacent object pairs (faces and sub-faces with a Surface boundary
+        condition) must have matching areas.
+
+    5. All Room volumes must be closed solids.
+
+    \b
+    Args:
+        model_file: Full path to a Model JSON file.
+    """
+    try:
+        json = not plain_text
+        if room_overlaps == 'True':
+            print('--room-overlaps option is deprecated. '
+                  'Use `honeybee validate room-collisions` instead.')
+            validate_room_collisions(model_file, json, output_file)
+        else:
+            validate_model(model_file, extension, json, output_file)
+    except Exception as e:
+        _logger.exception('Model validation failed.\n{}'.format(e))
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+def validate_model(model_file, extension='Generic', json=False, output_file=None,
+                   plain_text=True):
+    """Validate all properties of a Model file against the Honeybee schema.
+
+    This includes checking basic compliance with the 5 rules of honeybee geometry
+    as well as checks for all extension attributes.
+
+    Args:
+        model_file: Full path to a Honeybee Model file.
+        extension_name: Text for the name of the extension to be checked.
+            The value input here is case-insensitive such that "radiance"
+            and "Radiance" will both result in the model being checked for
+            validity with honeybee-radiance. This value can also be set to
+            "Generic" in order to run checks for all installed extensions.
+            Using "Generic" will run all except the most limiting of checks
+            (eg. DOE2's lack of support for courtyards) with the goal of
+            producing a model that is export-able to multiple engines (albeit
+            with a little extra postprocessing for particularly limited engines).
+            Some common dragonfly extension names that can be input here if they
+            are installed include:
+
+            * Radiance
+            * EnergyPlus
+            * DOE2
+            * IES
+            * IDAICE
+
+        json: Boolean to note whether the output validation report should be
+            formatted as a JSON object instead of plain text. (Default: False).
+        output_file: Optional file to output the full report of the validation.
+            If None, the string will simply be returned from this method.
+    """
+    report = Model.validate(model_file, 'check_for_extension', [extension], json)
+    return process_content_to_output(report, output_file)
+
+
+@validate.command('rooms-solid')
+@click.argument('model-file', type=click.Path(
+    exists=True, file_okay=True, dir_okay=False, resolve_path=True))
+@click.option(
+    '--plain-text/--json', ' /-j', help='Flag to note whether the output validation '
+    'report should be formatted as a JSON object instead of plain text. If set to JSON, '
+    'the output object will contain several attributes. An attribute called '
+    '"fatal_error" is a text string containing an exception if the Model failed to '
+    'serialize and will be an empty string if serialization was successful. An '
+    'attribute called "errors" will contain a list of JSON objects for each '
+    'invalid issue. A boolean attribute called "valid" will note whether the Model '
+    'is valid or not.',
+    default=True, show_default=True)
+@click.option(
+    '--output-file', '-f', help='Optional file to output the full report '
+    'of the validation. By default it will be printed out to stdout.',
+    type=click.File('w'), default='-')
+def validate_rooms_solid_cli(model_file, plain_text, output_file):
+    """Validate whether all Room volumes in a model are solid.
+
+    The returned result can include a list of all naked and non-manifold edges
+    preventing closed room volumes when --json is used. This is helpful for visually
+    identifying issues in geometry that are preventing the room volume from
+    validating as closed.
+
+    \b
+    Args:
+        model_file: Full path to a Honeybee Model file.
+    """
+    try:
+        json = not plain_text
+        validate_rooms_solid(model_file, json, output_file)
+    except Exception as e:
+        _logger.exception('Model room volume validation failed.\n{}'.format(e))
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+def validate_rooms_solid(model_file, json=False, output_file=None, plain_text=True):
+    """Get a list of all naked and non-manifold edges preventing closed room volumes.
+
+    This is helpful for visually identifying issues in geometry that are preventing
+    the room volume from reading as closed.
+
+    Args:
+        model_file: Full path to a Honeybee Model file.
+        json: Boolean to note whether the output validation report should be
+            formatted as a JSON object instead of plain text. (Default: False).
+        output_file: Optional file to output the full report of the validation.
+            If None, the string will simply be returned from this method.
+    """
+    report = Model.validate(model_file, 'check_rooms_solid', json_output=json)
+    return process_content_to_output(report, output_file)
+
+
+@validate.command('room-collisions')
+@click.argument('model-file', type=click.Path(
+    exists=True, file_okay=True, dir_okay=False, resolve_path=True))
+@click.option(
+    '--plain-text/--json', ' /-j', help='Flag to note whether the output validation '
+    'report should be formatted as a JSON object instead of plain text. If set to JSON, '
+    'the output object will contain several attributes. An attribute called '
+    '"fatal_error" is a text string containing an exception if the Model failed to '
+    'serialize and will be an empty string if serialization was successful. An '
+    'attribute called "errors" will contain a list of JSON objects for each '
+    'invalid issue. A boolean attribute called "valid" will note whether the Model '
+    'is valid or not.', default=True, show_default=True)
+@click.option(
+    '--output-file', '-f', help='Optional file to output the full report '
+    'of the validation. By default it will be printed out to stdout.',
+    type=click.File('w'), default='-')
+def validate_room_collisions_cli(model_file, plain_text, output_file):
+    """Validate whether Room collide with one another beyond the model tolerance.
+
+    \b
+    Args:
+        model_file: Full path to a Honeybee Model file.
+    """
+    try:
+        json = not plain_text
+        validate_room_collisions(model_file, json, output_file)
+    except Exception as e:
+        _logger.exception('Model room volume validation failed.\n{}'.format(e))
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+def validate_room_collisions(model_file, json=False, output_file=None, plain_text=True):
+    """Validate whether Room collide with one another beyond the model tolerance.
+
+    Args:
+        model_file: Full path to a Honeybee Model file.
+        json: Boolean to note whether the output validation report should be
+            formatted as a JSON object instead of plain text. (Default: False).
+        output_file: Optional file to output the full report of the validation.
+            If None, the string will simply be returned from this method.
+    """
+    report = Model.validate(model_file, 'check_room_volume_collisions', json_output=json)
+    return process_content_to_output(report, output_file)

honeybee/colorobj.py

@@ -0,0 +1,363 @@
+# coding=utf-8
+"""Module for coloring geometry with attributes."""
+from __future__ import division
+
+from .shademesh import ShadeMesh
+from .shade import Shade
+from .door import Door
+from .aperture import Aperture
+from .face import Face
+from .room import Room
+from .facetype import Floor
+from .search import get_attr_nested
+
+from ladybug.graphic import GraphicContainer
+from ladybug.legend import LegendParameters, LegendParametersCategorized
+from ladybug_geometry.geometry3d.pointvector import Point3D
+
+
+class _ColorObject(object):
+    """Base class for visualization objects.
+
+    Properties:
+        * legend_parameters
+        * attr_name
+        * attr_name_end
+        * attributes
+        * attributes_unique
+        * attributes_original
+        * min_point
+        * max_point
+        * graphic_container
+    """
+    __slots__ = ('_attr_name', '_legend_parameters', '_attr_name_end',
+                 '_attributes', '_attributes_unique', '_attributes_original',
+                 '_min_point', '_max_point')
+
+    def __init__(self, legend_parameters=None):
+        """Initialize ColorObject."""
+        # assign the legend parameters of this object
+        self.legend_parameters = legend_parameters
+
+        self._attr_name = None
+        self._attr_name_end = None
+        self._attributes = None
+        self._attributes_unique = None
+        self._attributes_original = None
+        self._min_point = None
+        self._max_point = None
+
+    @property
+    def legend_parameters(self):
+        """Get or set the legend parameters."""
+        return self._legend_parameters
+
+    @legend_parameters.setter
+    def legend_parameters(self, value):
+        if value is not None:
+            assert isinstance(value, LegendParameters) and not \
+                isinstance(value, LegendParametersCategorized), \
+                'Expected LegendParameters. Got {}.'.format(type(value))
+            self._legend_parameters = value
+        else:
+            self._legend_parameters = LegendParameters()
+
+    @property
+    def attr_name(self):
+        """Get a text string of an attribute that the input objects should have."""
+        return self._attr_name
+
+    @property
+    def attr_name_end(self):
+        """Get text for the last attribute in the attr_name.
+
+        Useful when attr_name is nested.
+        """
+        return self._attr_name_end
+
+    @property
+    def attributes(self):
+        """Get a tuple of text for the attributes assigned to the objects.
+
+        If the input attr_name is a valid attribute for the object but None is
+        assigned, the output will be 'None'. If the input attr_name is not valid
+        for the input object, 'N/A' will be returned.
+        """
+        return self._attributes
+
+    @property
+    def attributes_unique(self):
+        """Get a tuple of text for the unique attributes assigned to the objects."""
+        return self._attributes_unique
+
+    @property
+    def attributes_original(self):
+        """Get a tuple of objects for the attributes assigned to the objects.
+
+        These will follow the original object typing of the attribute and won't
+        be strings like the attributes.
+        """
+        return self._attributes_original
+
+    @property
+    def min_point(self):
+        """Get a Point3D for the minimum of the box around the objects."""
+        return self._min_point
+
+    @property
+    def max_point(self):
+        """Get a Point3D for the maximum of the box around the objects."""
+        return self._max_point
+
+    @property
+    def graphic_container(self):
+        """Get a ladybug GraphicContainer that relates to this object.
+
+        The GraphicContainer possesses almost all things needed to visualize the
+        ColorRooms object including the legend, value_colors, etc.
+        """
+        # produce a range of values from the collected attributes
+        attr_dict = {i: val for i, val in enumerate(self._attributes_unique)}
+        attr_dict_rev = {val: i for i, val in attr_dict.items()}
+        try:
+            values = tuple(attr_dict_rev[r_attr] for r_attr in self._attributes)
+        except KeyError:  # possibly caused by float cast to -0.0
+            values = []
+            for r_attr in self._attributes:
+                if r_attr == '-0.0':
+                    values.append(attr_dict_rev['0.0'])
+                else:
+                    values.append(attr_dict_rev[r_attr])
+
+        # produce legend parameters with an ordinal dict for the attributes
+        l_par = self.legend_parameters.duplicate()
+        if l_par.is_segment_count_default:
+            l_par.segment_count = len(self._attributes_unique)
+        l_par.ordinal_dictionary = attr_dict
+        if l_par.is_title_default:
+            l_par.title = self.attr_name_end.replace('_', ' ').title()
+
+        return GraphicContainer(values, self.min_point, self.max_point, l_par)
+
+    def _process_attribute_name(self, attr_name):
+        """Process the attribute name and assign it to this object."""
+        self._attr_name = str(attr_name)
+        at_split = self._attr_name.split('.')
+        if len(at_split) == 1:
+            self._attr_name_end = at_split[-1]
+        elif at_split[-1] == 'display_name':
+            self._attr_name_end = at_split[-2]
+        elif at_split[-1] == '__name__' and at_split[-2] == '__class__':
+            self._attr_name_end = at_split[-3]
+        else:
+            self._attr_name_end = at_split[-1]
+
+    def _process_attributes(self, hb_objs):
+        """Process the attributes of honeybee objects."""
+        nd = self.legend_parameters.decimal_count
+        attributes = [get_attr_nested(obj, self._attr_name, nd) for obj in hb_objs]
+        attributes_unique = set(attributes)
+        float_attr = [atr for atr in attributes_unique if isinstance(atr, float)]
+        str_attr = [atr for atr in attributes_unique if isinstance(atr, str)]
+        float_attr.sort()
+        str_attr.sort()
+        self._attributes = tuple(str(val) for val in attributes)
+        self._attributes_unique = tuple(str_attr) + tuple(str(val) for val in float_attr)
+        self._attributes_original = \
+            tuple(get_attr_nested(obj, self._attr_name, cast_to_str=False)
+                  for obj in hb_objs)
+
+    def _calculate_min_max(self, hb_objs):
+        """Calculate maximum and minimum Point3D for a set of rooms."""
+        st_rm_min, st_rm_max = hb_objs[0].geometry.min, hb_objs[0].geometry.max
+        min_pt = [st_rm_min.x, st_rm_min.y, st_rm_min.z]
+        max_pt = [st_rm_max.x, st_rm_max.y, st_rm_max.z]
+
+        for room in hb_objs[1:]:
+            rm_min, rm_max = room.geometry.min, room.geometry.max
+            if rm_min.x < min_pt[0]:
+                min_pt[0] = rm_min.x
+            if rm_min.y < min_pt[1]:
+                min_pt[1] = rm_min.y
+            if rm_min.z < min_pt[2]:
+                min_pt[2] = rm_min.z
+            if rm_max.x > max_pt[0]:
+                max_pt[0] = rm_max.x
+            if rm_max.y > max_pt[1]:
+                max_pt[1] = rm_max.y
+            if rm_max.z > max_pt[2]:
+                max_pt[2] = rm_max.z
+
+        self._min_point = Point3D(min_pt[0], min_pt[1], min_pt[2])
+        self._max_point = Point3D(max_pt[0], max_pt[1], max_pt[2])
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+
+class ColorRoom(_ColorObject):
+    """Object for visualizing room-level attributes.
+
+    Args:
+        rooms: An array of honeybee Rooms, which will be colored with the attribute.
+        attr_name: A text string of an attribute that the input rooms should have.
+            This can have '.' that separate the nested attributes from one another.
+            For example, 'properties.energy.program_type'.
+        legend_parameters: An optional LegendParameter object to change the display
+            of the ColorRoom (Default: None).
+
+    Properties:
+        * rooms
+        * attr_name
+        * legend_parameters
+        * attr_name_end
+        * attributes
+        * attributes_unique
+        * attributes_original
+        * floor_faces
+        * graphic_container
+        * min_point
+        * max_point
+    """
+    __slots__ = ('_rooms',)
+
+    def __init__(self, rooms, attr_name, legend_parameters=None):
+        """Initialize ColorRoom."""
+        try:  # check the input rooms
+            rooms = tuple(rooms)
+        except TypeError:
+            raise TypeError('Input rooms must be an array. Got {}.'.format(type(rooms)))
+        assert len(rooms) > 0, 'ColorRooms must have at least one room.'
+        for room in rooms:
+            assert isinstance(room, Room), 'Expected honeybee Room for ' \
+                'ColorRoom rooms. Got {}.'.format(type(room))
+        self._rooms = rooms
+        self._calculate_min_max(rooms)
+
+        # assign the legend parameters of this object
+        self.legend_parameters = legend_parameters
+
+        # get the attributes of the input rooms
+        self._process_attribute_name(attr_name)
+        self._process_attributes(rooms)
+
+    @property
+    def rooms(self):
+        """Get a tuple of honeybee Rooms assigned to this object."""
+        return self._rooms
+
+    @property
+    def floor_faces(self):
+        """Get a nested array with each sub-array having all floor Face3Ds of each room.
+
+        This is useful for producing visualizations since coloring floors or rooms
+        instead of the entire room solid allows more of the model to be viewed at once.
+        """
+        flr_faces = []
+        for room in self.rooms:
+            flr_faces.append(
+                [face.geometry for face in room.faces if isinstance(face.type, Floor)])
+        return flr_faces
+
+    def __repr__(self):
+        """Color Room representation."""
+        return 'Color Room:\n{} Rooms\n{}'.format(len(self.rooms), self.attr_name_end)
+
+
+class ColorFace(_ColorObject):
+    """Object for visualizing face and sub-face level attributes.
+
+    Args:
+        faces: An array of honeybee Faces, Apertures, Doors, Shades and/or ShadeMeshes
+            which will be colored with their attributes.
+        attr_name: A text string of an attribute that the input faces should have.
+            This can have '.' that separate the nested attributes from one another.
+            For example, 'properties.energy.construction'.
+        legend_parameters: An optional LegendParameter object to change the display
+            of the ColorFace (Default: None).
+
+    Properties:
+        * faces
+        * attr_name
+        * legend_parameters
+        * flat_faces
+        * flat_geometry
+        * attr_name_end
+        * attributes
+        * attributes_unique
+        * attributes_original
+        * floor_faces
+        * graphic_container
+        * min_point
+        * max_point
+    """
+    __slots__ = ('_faces', '_flat_faces', '_flat_geometry')
+
+    def __init__(self, faces, attr_name, legend_parameters=None):
+        """Initialize ColorFace."""
+        try:  # check the input faces
+            faces = tuple(faces)
+        except TypeError:
+            raise TypeError('Input faces must be an array. Got {}.'.format(type(faces)))
+        assert len(faces) > 0, 'ColorFaces must have at least one face.'
+        flat_f = []
+        for face in faces:
+            if isinstance(face, Face):
+                flat_f.append(face)
+                flat_f.extend(face.shades)
+                for ap in face.apertures:
+                    flat_f.append(ap)
+                    flat_f.extend(ap.shades)
+                for dr in face.doors:
+                    flat_f.append(dr)
+                    flat_f.extend(dr.shades)
+            elif isinstance(face, (Aperture, Door)):
+                flat_f.append(face)
+                flat_f.extend(face.shades)
+            elif isinstance(face, Shade):
+                flat_f.append(face)
+            elif isinstance(face, ShadeMesh):
+                flat_f.append(face)
+            else:
+                raise ValueError(
+                    'Expected honeybee Face, Aperture, Door, Shade or ShadeMesh '
+                    'for ColorFaces. Got {}.'.format(type(face)))
+        self._faces = faces
+        self._flat_faces = tuple(flat_f)
+        self._flat_geometry = tuple(face.geometry if not isinstance(face, Face)
+                                    else face.punched_geometry for face in flat_f)
+        self._calculate_min_max(faces)
+
+        # assign the legend parameters of this object
+        self.legend_parameters = legend_parameters
+
+        # get the attributes of the input faces
+        self._process_attribute_name(attr_name)
+        self._process_attributes(flat_f)
+
+    @property
+    def faces(self):
+        """Get the honeybee Faces, Apertures, Doors and Shades assigned to this object.
+        """
+        return self._faces
+
+    @property
+    def flat_faces(self):
+        """Get non-nested honeybee Faces, Apertures, Doors and Shades on this object.
+
+        The objects here align with the attributes and graphic_container colors.
+        """
+        return self._flat_faces
+
+    @property
+    def flat_geometry(self):
+        """Get non-nested array of faces on this object.
+
+        The geometries here align with the attributes and graphic_container colors.
+        """
+        return self._flat_geometry
+
+    def __repr__(self):
+        """Color Room representation."""
+        return 'Color Faces:\n{} Faces\n{}'.format(len(self.faces), self.attr_name_end)

honeybee/config.json

@@ -0,0 +1,5 @@
+{
+    "__comment__": "Add full paths to folders (eg. C:/sim_folder, /usr/local/sim_folder).",
+    "default_simulation_folder": "",
+    "default_standards_folder": ""
+}