honeybee-energy 1.116.106__py3-none-any.whl

honeybee_energy/lib/_loadmaterials.py

@@ -0,0 +1,83 @@
+"""Load all materials from the JSON libraries."""
+from honeybee_energy.config import folders
+from honeybee_energy.material.dictutil import dict_to_material
+
+import os
+import json
+
+
+# empty dictionaries to hold loaded materials
+_opaque_materials = {}
+_window_materials = {}
+
+
+# first load the honeybee defaults
+with open(folders.defaults_file) as json_file:
+    default_data = json.load(json_file)['materials']
+for mat_dict in default_data:
+    mat_obj = dict_to_material(mat_dict, False)
+    mat_obj.lock()
+    if mat_obj.is_window_material:
+        _window_materials[mat_dict['identifier']] = mat_obj
+    else:
+        _opaque_materials[mat_dict['identifier']] = mat_obj
+_default_mats = set(list(_opaque_materials.keys()) + list(_window_materials.keys()))
+
+
+# then load honeybee extension data into a dictionary but don't make the objects yet
+_opaque_mat_standards_dict = {}
+_window_mat_standards_dict = {}
+
+for ext_folder in folders.standards_extension_folders:
+    _data_dir = os.path.join(ext_folder, 'constructions')
+    _opaque_dir = os.path.join(_data_dir, 'opaque_material.json')
+    if os.path.isfile(_opaque_dir):
+        with open(_opaque_dir, 'r') as f:
+            _opaque_mat_standards_dict.update(json.load(f))
+    _window_dir = os.path.join(_data_dir, 'window_material.json')
+    if os.path.isfile(_window_dir):
+        with open(_window_dir, 'r') as f:
+            _window_mat_standards_dict.update(json.load(f))
+
+
+# then load material JSONs from the default and user-supplied files
+def load_material_object(mat_dict, opaque_mats, window_mats):
+    """Load a material object from a dictionary and add it to the library dict."""
+    try:
+        mat_obj = dict_to_material(mat_dict, False)
+        if mat_obj is not None:
+            mat_obj.lock()
+            assert mat_dict['identifier'] not in _default_mats, 'Cannot overwrite ' \
+                'default material "{}".'.format(mat_dict['identifier'])
+            if mat_obj.is_window_material:
+                window_mats[mat_dict['identifier']] = mat_obj
+            else:
+                opaque_mats[mat_dict['identifier']] = mat_obj
+    except (TypeError, KeyError):
+        pass  # not a Honeybee Material JSON; possibly a comment
+
+
+def load_materials_from_folder(construction_lib_folder):
+    """Load all of the material layer objects from a construction standards folder.
+
+    Args:
+        construction_lib_folder: Path to a constructions sub-folder within a
+            honeybee standards folder.
+    """
+    opaque_mats, window_mats = {}, {}
+    for f in os.listdir(construction_lib_folder):
+        f_path = os.path.join(construction_lib_folder, f)
+        if os.path.isfile(f_path) and f_path.endswith('.json'):
+            with open(f_path) as json_file:
+                data = json.load(json_file)
+            if 'type' in data:  # single object
+                load_material_object(data, opaque_mats, window_mats)
+            else:  # a collection of several objects
+                for mat_id in data:
+                    load_material_object(data[mat_id], opaque_mats, window_mats)
+    return opaque_mats, window_mats
+
+
+opaque_m, window_m = load_materials_from_folder(folders.construction_lib)
+_opaque_materials.update(opaque_m)
+_window_materials.update(window_m)

honeybee_energy/lib/_loadprogramtypes.py

@@ -0,0 +1,125 @@
+"""Load all program types from the JSON libraries."""
+from honeybee_energy.config import folders
+from honeybee_energy.programtype import ProgramType
+
+from ._loadschedules import _schedules
+
+import os
+import json
+
+
+# empty dictionary to hold loaded program types
+_program_types = {}
+
+
+# first load the honeybee defaults
+with open(folders.defaults_file) as json_file:
+    default_data = json.load(json_file)['program_types']
+for pro_dict in default_data:
+    program = ProgramType.from_dict_abridged(pro_dict, _schedules)
+    program.lock()
+    _program_types[pro_dict['identifier']] = program
+_default_programs = set(list(_program_types.keys()))
+
+
+def _add_schedule(scheds, p_type_dict, load_id, sch_id):
+    import honeybee_energy.lib.schedules as _s
+    try:
+        sch_id = p_type_dict[load_id][sch_id]
+        if sch_id not in scheds:
+            scheds[sch_id] = _s.schedule_by_identifier(sch_id)
+    except KeyError:
+        pass  # key is not included
+
+
+# then load honeybee extension data into a dictionary but don't make the objects yet
+_program_types_standards_dict = {}
+_program_types_standards_registry = {}
+_building_programs_dict = {}
+
+for ext_folder in folders.standards_extension_folders:
+    _data_dir = os.path.join(ext_folder, 'programtypes')
+    for _p_type_json in os.listdir(_data_dir):
+        if _p_type_json.endswith('.json'):
+            _p_type_dir = os.path.join(_data_dir, _p_type_json)
+            with open(_p_type_dir, 'r') as f:
+                _program_types_standards_dict.update(json.load(f))
+    _data_dir = os.path.join(ext_folder, 'programtypes_registry')
+    if os.path.isdir(_data_dir):
+        for _p_type_json in os.listdir(_data_dir):
+            if _p_type_json.endswith('_registry.json'):
+                _p_type_dir = os.path.join(_data_dir, _p_type_json)
+                vintage = _p_type_json.split('_registry.json')[0]
+                try:
+                    with open(_p_type_dir, 'r') as f:
+                        _program_types_standards_registry[vintage] = json.load(f)
+                except FileNotFoundError:
+                    pass
+    _bld_file = os.path.join(ext_folder, 'building_mix.json')
+    if os.path.isfile(_bld_file):
+        with open(_bld_file, 'r') as f:
+            _building_programs_dict.update(json.load(f))
+
+
+# then load program types from the user-supplied files
+def load_program_object(pro_dict, loaded_schedules, p_types, misc_scheds):
+    """Load a program object from a dictionary and add it to the _program_types dict."""
+    try:
+        if pro_dict['type'] == 'ProgramTypeAbridged':
+            program = ProgramType.from_dict_abridged(pro_dict, loaded_schedules)
+        else:
+            program = ProgramType.from_dict(pro_dict)
+            misc_scheds.extend(program.schedules)
+        program.lock()
+        assert pro_dict['identifier'] not in _default_programs, 'Cannot overwrite ' \
+            'default program type "{}".'.format(pro_dict['identifier'])
+        p_types[pro_dict['identifier']] = program
+    except Exception:
+        try:
+            if pro_dict['type'] == 'ProgramTypeAbridged':
+                schedules = loaded_schedules
+                _add_schedule(schedules, pro_dict, 'people', 'occupancy_schedule')
+                _add_schedule(schedules, pro_dict, 'people', 'activity_schedule')
+                _add_schedule(schedules, pro_dict, 'lighting', 'schedule')
+                _add_schedule(schedules, pro_dict, 'electric_equipment', 'schedule')
+                _add_schedule(schedules, pro_dict, 'gas_equipment', 'schedule')
+                _add_schedule(schedules, pro_dict, 'service_hot_water', 'schedule')
+                _add_schedule(schedules, pro_dict, 'infiltration', 'schedule')
+                _add_schedule(schedules, pro_dict, 'ventilation', 'schedule')
+                _add_schedule(schedules, pro_dict, 'setpoint', 'heating_schedule')
+                _add_schedule(schedules, pro_dict, 'setpoint', 'cooling_schedule')
+                _add_schedule(schedules, pro_dict, 'setpoint', 'humidifying_schedule')
+                _add_schedule(schedules, pro_dict, 'setpoint', 'dehumidifying_schedule')
+            p_types[pro_dict['identifier']] = \
+                ProgramType.from_dict_abridged(pro_dict, schedules)
+        except Exception:
+            pass  # not a Honeybee ProgramType JSON; possibly a comment
+
+
+def load_programtypes_from_folder(programtypes_lib_folder, loaded_schedules):
+    """Load all of the ProgramTypes objects from a programtypes standards folder.
+
+    Args:
+        programtypes_lib_folder: Path to a programtypes sub-folder within a
+            honeybee standards folder.
+        loaded_schedules: A dictionary of schedules that have already been
+            loaded from the library.
+    """
+    p_types, misc_scheds = {}, []
+    for f in os.listdir(programtypes_lib_folder):
+        f_path = os.path.join(programtypes_lib_folder, f)
+        if os.path.isfile(f_path) and f_path.endswith('.json'):
+            with open(f_path, 'r') as json_file:
+                p_dict = json.load(json_file)
+            if 'type' in p_dict:  # single object
+                load_program_object(p_dict, loaded_schedules, p_types, misc_scheds)
+            else:  # a collection of several objects
+                for p_id in p_dict:
+                    load_program_object(
+                        p_dict[p_id], loaded_schedules, p_types, misc_scheds)
+    return p_types, misc_scheds
+
+
+loaded_p_types, misc_s = \
+    load_programtypes_from_folder(folders.programtype_lib, _schedules)
+_program_types.update(loaded_p_types)

honeybee_energy/lib/_loadschedules.py

@@ -0,0 +1,87 @@
+"""Load all schedules from the IDF libraries."""
+from honeybee_energy.config import folders
+from honeybee_energy.schedule.ruleset import ScheduleRuleset
+from honeybee_energy.schedule.dictutil import dict_abridged_to_schedule, \
+    dict_to_schedule
+
+from ._loadtypelimits import _schedule_type_limits
+
+import os
+import json
+
+
+# empty dictionary to hold loaded schedules
+_schedules = {}
+
+
+# first load the honeybee defaults
+with open(folders.defaults_file) as json_file:
+    default_data = json.load(json_file)['schedules']
+for sch_dict in default_data:
+    sch_obj = dict_abridged_to_schedule(sch_dict, _schedule_type_limits, False)
+    sch_obj.lock()
+    _schedules[sch_dict['identifier']] = sch_obj
+_default_schedules = set(list(_schedules.keys()))
+
+
+# then load honeybee extension data into a dictionary but don't make the objects yet
+_schedule_standards_dict = {}
+
+for ext_folder in folders.standards_extension_folders:
+    _data_dir = os.path.join(ext_folder, 'schedules', 'schedule.json')
+    if os.path.isfile(_data_dir):
+        with open(_data_dir, 'r') as f:
+            _schedule_standards_dict.update(json.load(f))
+
+
+# then load schedules from the user-supplied files
+def lock_and_check_schedule(sch):
+    """Lock a schedule and check that it's not overwriting a default."""
+    sch.lock()
+    assert sch.identifier not in _default_schedules, 'Cannot overwrite ' \
+        'default schedule "{}".'.format(sch.identifier)
+
+
+def load_schedule_object(sch_dict, loaded_type_limits, scheds):
+    """Load a schedule object from a dictionary and add it to the scheds dict."""
+    try:
+        sch_obj = dict_abridged_to_schedule(sch_dict, loaded_type_limits, False)
+        if sch_obj is None:
+            sch_obj = dict_to_schedule(sch_dict, False)
+        if sch_obj is not None:
+            lock_and_check_schedule(sch_obj)
+            scheds[sch_dict['identifier']] = sch_obj
+    except (TypeError, KeyError, ValueError):
+        pass  # not a Honeybee Schedule JSON; possibly a comment
+
+
+def load_schedules_from_folder(schedule_lib_folder, loaded_type_limits):
+    """Load all of the schedule objects from a schedule standards folder.
+
+    Args:
+        schedule_lib_folder: Path to a schedules sub-folder within a honeybee
+            standards folder.
+        loaded_type_limits: A dictionary of type limits that have already been
+            loaded from the library.
+    """
+    scheds = {}
+    for f in os.listdir(schedule_lib_folder):
+        f_path = os.path.join(schedule_lib_folder, f)
+        if os.path.isfile(f_path):
+            if f_path.endswith('.idf'):
+                schedule_rulesets = ScheduleRuleset.extract_all_from_idf_file(f_path)
+                for sch in schedule_rulesets:
+                    lock_and_check_schedule(sch)
+                    scheds[sch.identifier] = sch
+            elif f_path.endswith('.json'):  # parse as a honeybee JSON
+                with open(f_path) as json_file:
+                    data = json.load(json_file)
+                if 'type' in data:  # single object
+                    load_schedule_object(data, loaded_type_limits, scheds)
+                for sch_id in data:  # a collection of several objects
+                    load_schedule_object(data[sch_id], loaded_type_limits, scheds)
+    return scheds
+
+
+u_scheds = load_schedules_from_folder(folders.schedule_lib, _schedule_type_limits)
+_schedules.update(u_scheds)

honeybee_energy/lib/_loadtypelimits.py

@@ -0,0 +1,64 @@
+"""Load all schedule type limits from the standards library."""
+from honeybee_energy.config import folders
+from honeybee_energy.schedule.typelimit import ScheduleTypeLimit
+
+import os
+import json
+
+
+# empty dictionary to hold loaded schedule type limits
+_schedule_type_limits = {}
+
+
+# first load the honeybee defaults
+with open(folders.defaults_file) as json_file:
+    default_data = json.load(json_file)['schedule_type_limits']
+for stl_dict in default_data:
+    stl_obj = ScheduleTypeLimit.from_dict(stl_dict)
+    _schedule_type_limits[stl_dict['identifier']] = stl_obj
+_default_stls = set(list(_schedule_type_limits.keys()))
+
+
+# then load schedule types from the user-supplied files
+def check_and_add_schedule_type_limit(stl, type_lms):
+    """Check that a schedule type limit is not overwriting a default and add it."""
+    # we won't raise an error for this case as schedule types are fairly universal
+    if stl.identifier not in _default_stls:
+        type_lms[stl.identifier] = stl
+
+
+def load_type_limits_from_folder(schedule_lib_folder):
+    """Load all of the type limit objects from a schedule standards folder.
+
+    Args:
+        schedule_lib_folder: Path to a schedules sub-folder within a honeybee
+            standards folder.
+    """
+    type_limits = {}
+    for f in os.listdir(schedule_lib_folder):
+        f_path = os.path.join(schedule_lib_folder, f)
+        if os.path.isfile(f_path):
+            if f_path.endswith('.idf'):
+                schedule_type_limits = ScheduleTypeLimit.extract_all_from_idf_file(f_path)
+                for typ in schedule_type_limits:
+                    check_and_add_schedule_type_limit(typ, type_limits)
+            elif f_path.endswith('.json'):
+                with open(f_path) as json_file:
+                    data = json.load(json_file)
+                if 'type' in data and data['type'] == 'ScheduleTypeLimit':  # single object
+                    check_and_add_schedule_type_limit(
+                        ScheduleTypeLimit.from_dict(data), type_limits)
+                else:  # a collection of several objects
+                    for stl_id in data:
+                        try:
+                            stl_dict = data[stl_id]
+                            if stl_dict['type'] == 'ScheduleTypeLimit':
+                                check_and_add_schedule_type_limit(
+                                    ScheduleTypeLimit.from_dict(stl_dict), type_limits)
+                        except (TypeError, KeyError):
+                            pass  # not a ScheduleTypeLimit JSON; possibly a comment
+    return type_limits
+
+
+type_l = load_type_limits_from_folder(folders.schedule_lib)
+_schedule_type_limits.update(type_l)

honeybee_energy/lib/constructions.py

@@ -0,0 +1,207 @@
+"""Load all of the constructions and materials from the IDF libraries."""
+from honeybee_energy.construction.opaque import OpaqueConstruction
+from honeybee_energy.construction.window import WindowConstruction
+from honeybee_energy.construction.windowshade import WindowConstructionShade
+from honeybee_energy.construction.dynamic import WindowConstructionDynamic
+from honeybee_energy.construction.shade import ShadeConstruction
+from honeybee_energy.construction.air import AirBoundaryConstruction
+from ._loadconstructions import _opaque_constructions, _window_constructions, \
+    _shade_constructions, _opaque_constr_standards_dict, _window_constr_standards_dict, \
+    _shade_constr_standards_dict
+
+import honeybee_energy.lib.materials as _m
+import honeybee_energy.lib.schedules as _s
+
+
+# establish variables for the default constructions used across the library
+generic_exterior_wall = _opaque_constructions['Generic Exterior Wall']
+generic_interior_wall = _opaque_constructions['Generic Interior Wall']
+generic_underground_wall = _opaque_constructions['Generic Underground Wall']
+generic_exposed_floor = _opaque_constructions['Generic Exposed Floor']
+generic_interior_floor = _opaque_constructions['Generic Interior Floor']
+generic_ground_slab = _opaque_constructions['Generic Ground Slab']
+generic_roof = _opaque_constructions['Generic Roof']
+generic_interior_ceiling = _opaque_constructions['Generic Interior Ceiling']
+generic_underground_roof = _opaque_constructions['Generic Underground Roof']
+generic_double_pane = _window_constructions['Generic Double Pane']
+generic_single_pane = _window_constructions['Generic Single Pane']
+generic_exterior_door = _opaque_constructions['Generic Exterior Door']
+generic_interior_door = _opaque_constructions['Generic Interior Door']
+air_boundary = _opaque_constructions['Generic Air Boundary']
+generic_context = _shade_constructions['Generic Context']
+generic_shade = _shade_constructions['Generic Shade']
+try:
+    ceiling_plenum_bottom = _opaque_constructions['Ceiling Plenum Bottom']
+    floor_plenum_top = _opaque_constructions['Floor Plenum Top']
+except KeyError:  # older version of honeybee-standards
+    ceiling_plenum_bottom = \
+        OpaqueConstruction('Ceiling Plenum Bottom', [_m.acoustic_tile])
+    floor_plenum_top = OpaqueConstruction('Floor Plenum Top', [_m.wood])
+
+# make lists of construction identifiers to look up items in the library
+OPAQUE_CONSTRUCTIONS = tuple(_opaque_constructions.keys()) + \
+    tuple(_opaque_constr_standards_dict.keys())
+WINDOW_CONSTRUCTIONS = tuple(_window_constructions.keys()) + \
+    tuple(_window_constr_standards_dict.keys())
+SHADE_CONSTRUCTIONS = tuple(_shade_constructions.keys()) + \
+    tuple(_shade_constr_standards_dict.keys())
+
+
+def opaque_construction_by_identifier(construction_identifier):
+    """Get an opaque construction from the library given the construction identifier.
+
+    Args:
+        construction_identifier: A text string for the identifier of the construction.
+    """
+    try:
+        return _opaque_constructions[construction_identifier]
+    except KeyError:
+        try:  # search the extension data
+            constr_dict = _opaque_constr_standards_dict[construction_identifier]
+            if constr_dict['type'] == 'OpaqueConstructionAbridged':
+                mats = {}
+                mat_key = 'layers' if 'layers' in constr_dict else 'materials'
+                for mat in constr_dict[mat_key]:
+                    mats[mat] = _m.opaque_material_by_identifier(mat)
+                return OpaqueConstruction.from_dict_abridged(constr_dict, mats)
+            else:  # AirBoundaryConstruction
+                try:
+                    sch_id = constr_dict['air_mixing_schedule']
+                    schs = {sch_id: _s.schedule_by_identifier(sch_id)}
+                except KeyError:  # no air mixing key provided
+                    schs = {}
+                return AirBoundaryConstruction.from_dict_abridged(constr_dict, schs)
+        except KeyError:  # construction is nowhere to be found; raise an error
+            raise ValueError(
+                '"{}" was not found in the opaque energy construction library.'.format(
+                    construction_identifier))
+
+
+def window_construction_by_identifier(construction_identifier):
+    """Get an window construction from the library given the construction identifier.
+
+    Args:
+        construction_identifier: A text string for the identifier of the construction.
+    """
+    try:
+        return _window_constructions[construction_identifier]
+    except KeyError:
+        try:  # search the extension data
+            constr_dict = _window_constr_standards_dict[construction_identifier]
+            if constr_dict['type'] == 'WindowConstructionAbridged':
+                mats = {}
+                mat_key = 'layers' if 'layers' in constr_dict else 'materials'
+                for mat in constr_dict[mat_key]:
+                    mats[mat] = _m.window_material_by_identifier(mat)
+                return WindowConstruction.from_dict_abridged(constr_dict, mats)
+            elif constr_dict['type'] == 'WindowConstructionShadeAbridged':
+                mats = {}
+                mat_key = 'layers' if 'layers' in constr_dict['window_construction'] \
+                    else 'materials'
+                for mat in constr_dict['window_construction'][mat_key]:
+                    mats[mat] = _m.window_material_by_identifier(mat)
+                shd_mat = constr_dict['shade_material']
+                mats[shd_mat] = _m.window_material_by_identifier(shd_mat)
+                try:
+                    sch_id = constr_dict['schedule']
+                    schs = {sch_id: _s.schedule_by_identifier(sch_id)}
+                except KeyError:  # no schedule key provided
+                    schs = {}
+                return WindowConstructionShade.from_dict_abridged(
+                    constr_dict, mats, schs)
+            elif constr_dict['type'] == 'WindowConstructionDynamicAbridged':
+                mats = {}
+                for con in constr_dict['constructions']:
+                    for mat in constr_dict['materials']:
+                        mats[mat] = _m.window_material_by_identifier(mat)
+                sch_id = constr_dict['schedule']
+                schs = {sch_id: _s.schedule_by_identifier(sch_id)}
+                return WindowConstructionDynamic.from_dict_abridged(
+                    constr_dict, mats, schs)
+        except KeyError:  # construction is nowhere to be found; raise an error
+            raise ValueError(
+                '"{}" was not found in the window energy construction library.'.format(
+                    construction_identifier))
+
+
+def shade_construction_by_identifier(construction_identifier):
+    """Get an shade construction from the library given the construction identifier.
+
+    Args:
+        construction_identifier: A text string for the identifier of the construction.
+    """
+    try:
+        return _shade_constructions[construction_identifier]
+    except KeyError:
+        try:  # search the extension data
+            constr_dict = _shade_constr_standards_dict[construction_identifier]
+            return ShadeConstruction.from_dict(constr_dict)
+        except KeyError:  # construction is nowhere to be found; raise an error
+            raise ValueError(
+                '"{}" was not found in the shade energy construction library.'.format(
+                    construction_identifier))
+
+
+def lib_dict_abridged_to_construction(constr_dict, materials, schedules):
+    """Get a Python object of a Construction from an abridged dictionary.
+
+    When the sub-objects needed to create the construction are not available
+    in the resources provided, the current standards library will be searched.
+
+    Args:
+        constr_dict: An abridged dictionary of any Honeybee energy construction.
+        materials: Dictionary of all material objects that might be used in the
+            construction with the material identifiers as the keys.
+        schedules: Dictionary of all schedule objects that might be used in the
+            construction with the schedule identifiers as the keys.
+
+    Returns:
+        A Python object derived from the input constr_dict.
+    """
+    try:  # get the type key from the dictionary
+        constr_type = constr_dict['type']
+    except KeyError:
+        raise ValueError('Construction dictionary lacks required "type" key.')
+
+    if constr_type == 'OpaqueConstructionAbridged':
+        for mat_id in constr_dict['materials']:
+            if mat_id not in materials:
+                materials[mat_id] = _m.opaque_material_by_identifier(mat_id)
+        return OpaqueConstruction.from_dict_abridged(constr_dict, materials)
+    elif constr_type == 'WindowConstructionAbridged':
+        for mat_id in constr_dict['materials']:
+            if mat_id not in materials:
+                materials[mat_id] = _m.window_material_by_identifier(mat_id)
+        return WindowConstruction.from_dict_abridged(constr_dict, materials)
+    elif constr_type == 'WindowConstructionShadeAbridged':
+        all_mat = constr_dict['window_construction']['materials'] + \
+            [constr_dict['shade_material']]
+        for mat_id in all_mat:
+            if mat_id not in materials:
+                materials[mat_id] = _m.window_material_by_identifier(mat_id)
+        if 'schedule' in constr_dict and constr_dict['schedule'] is not None:
+            if constr_dict['schedule'] not in schedules:
+                schedules[constr_dict['schedule']] = \
+                    _s.schedule_by_identifier(constr_dict['schedule'])
+        return WindowConstructionShade.from_dict_abridged(
+            constr_dict, materials, schedules)
+    elif constr_type == 'WindowConstructionDynamicAbridged':
+        for c_abr in constr_dict['constructions']:
+            for mat_id in c_abr['materials']:
+                if mat_id not in materials:
+                    materials[mat_id] = _m.window_material_by_identifier(mat_id)
+        if constr_dict['schedule'] not in schedules:
+            schedules[constr_dict['schedule']] = \
+                _s.schedule_by_identifier(constr_dict['schedule'])
+        return WindowConstructionDynamic.from_dict_abridged(
+            constr_dict, materials, schedules)
+    elif constr_type == 'ShadeConstruction':
+        return ShadeConstruction.from_dict(constr_dict)
+    elif constr_type == 'AirBoundaryConstructionAbridged':
+        if constr_dict['air_mixing_schedule'] not in schedules:
+            schedules[constr_dict['air_mixing_schedule']] = \
+                _s.schedule_by_identifier(constr_dict['air_mixing_schedule'])
+        return AirBoundaryConstruction.from_dict_abridged(constr_dict, schedules)
+    else:
+        raise ValueError(
+            '{} is not a recognized energy Construction type'.format(constr_type))

honeybee_energy/lib/constructionsets.py

@@ -0,0 +1,95 @@
+"""Collection of construction sets."""
+from honeybee_energy.constructionset import ConstructionSet
+from ._loadconstructionsets import _construction_sets, _construction_set_standards_dict
+
+import honeybee_energy.lib.constructions as _c
+
+
+# establish variables for the default construction sets used across the library
+generic_construction_set = _construction_sets['Default Generic Construction Set']
+
+
+# make lists of program types to look up items in the library
+CONSTRUCTION_SETS = tuple(_construction_sets.keys()) + \
+    tuple(_construction_set_standards_dict.keys())
+
+
+def construction_set_by_identifier(construction_set_identifier):
+    """Get a construction_set from the library given its identifier.
+
+    Args:
+        construction_set_identifier: A text string for the identifier of the
+            ConstructionSet.
+    """
+    try:
+        return _construction_sets[construction_set_identifier]
+    except KeyError:
+        try:  # search the extension data
+            con_set_dict = _construction_set_standards_dict[construction_set_identifier]
+            constrs = _constrs_from_set_dict(con_set_dict)
+            return ConstructionSet.from_dict_abridged(con_set_dict, constrs)
+        except KeyError:  # construction is nowhere to be found; raise an error
+            raise ValueError(
+                '"{}" was not found in the construction set library.'.format(
+                    construction_set_identifier))
+
+
+def _constrs_from_set_dict(con_set_dict):
+    """Get a dictionary of constructions used in a ConstructionSetAbridged dictionary.
+    """
+    constrs = {}
+    for key in con_set_dict:
+        if isinstance(con_set_dict[key], dict):
+            sub_dict = con_set_dict[key]
+            for sub_key in sub_dict:
+                if sub_key != 'type':
+                    try:
+                        constrs[sub_dict[sub_key]] = \
+                            _c.opaque_construction_by_identifier(sub_dict[sub_key])
+                    except ValueError:
+                        constrs[sub_dict[sub_key]] = \
+                            _c.window_construction_by_identifier(sub_dict[sub_key])
+        elif key == 'shade_construction':
+            constrs[con_set_dict[key]] = \
+                _c.shade_construction_by_identifier(con_set_dict[key])
+        elif key == 'air_boundary_construction':
+            constrs[con_set_dict[key]] = \
+                _c.opaque_construction_by_identifier(con_set_dict[key])
+    return constrs
+
+
+def lib_dict_abridged_to_construction_set(con_set_dict, constructions):
+    """Get a Python object of a ConstructionSet from an abridged dictionary.
+
+    When the sub-objects needed to create the construction set are not available
+    in the resources provided, the current standards library will be searched.
+
+    Args:
+        con_set_dict: An abridged dictionary of a Honeybee ConstructionSet.
+        constructions: Dictionary of all construction objects that might be used in the
+            construction set with the construction identifiers as the keys.
+
+    Returns:
+        A Python object derived from the input con_set_dict.
+    """
+    for key in con_set_dict:
+        if isinstance(con_set_dict[key], dict):
+            sub_dict = con_set_dict[key]
+            for sub_key in sub_dict:
+                if sub_key == 'type' or sub_key in constructions:
+                    continue
+                if sub_dict[sub_key] not in constructions:
+                    try:
+                        constructions[sub_dict[sub_key]] = \
+                            _c.opaque_construction_by_identifier(sub_dict[sub_key])
+                    except ValueError:
+                        constructions[sub_dict[sub_key]] = \
+                            _c.window_construction_by_identifier(sub_dict[sub_key])
+        elif key == 'shade_construction' and con_set_dict[key] not in constructions:
+            constructions[con_set_dict[key]] = \
+                _c.shade_construction_by_identifier(con_set_dict[key])
+        elif key == 'air_boundary_construction' \
+                and con_set_dict[key] not in constructions:
+            constructions[con_set_dict[key]] = \
+                _c.opaque_construction_by_identifier(con_set_dict[key])
+    return ConstructionSet.from_dict_abridged(con_set_dict, constructions)