dragonfly-doe2 0.12.9__py3-none-any.whl

dragonfly_doe2/properties/room2d.py

@@ -0,0 +1,298 @@
+# coding=utf-8
+"""Room2D DOE-2 Properties."""
+from honeybee.typing import float_in_range, float_positive
+from honeybee.altnumber import autocalculate
+from honeybee_doe2.properties.room import RoomDoe2Properties
+
+
+class Room2DDoe2Properties(object):
+    """DOE-2 Properties for Dragonfly Room2D.
+
+    Args:
+        host: A dragonfly_core Room2D object that hosts these properties.
+        assigned_flow: A number for the design supply air flow rate for the zone
+            the Room2D is assigned to (cfm). This establishes the minimum allowed
+            design air flow. Note that the actual design flow may be larger. If
+            None, this parameter will not be written into the INP. (Default: None).
+        flow_per_area: A number for the design supply air flow rate to
+            the zone per unit floor area (cfm/ft2). If None, this parameter
+            will not be written into the INP. (Default: None).
+        min_flow_ratio: A number between 0 and 1 for the minimum allowable zone
+            air supply flow rate, expressed as a fraction of design flow rate.
+            Applicable to variable-volume type systems only. If None, this parameter
+            will not be written into the INP. (Default: None).
+        min_flow_per_area: A number for the minimum air flow per square foot of
+            floor area (cfm/ft2). This is an alternative way of specifying the
+            min_flow_ratio. If None, this parameter will not be written into
+            the INP. (Default: None).
+        hmax_flow_ratio: A number between 0 and 1 for the ratio of the maximum
+            (or fixed) heating airflow to the cooling airflow. The specific
+            meaning varies according to the type of zone terminal. If None, this
+            parameter will not be written into the INP. (Default: None).
+
+    Properties:
+        * host
+        * assigned_flow
+        * flow_per_area
+        * min_flow_ratio
+        * min_flow_per_area
+        * hmax_flow_ratio
+    """
+    __slots__ = (
+        '_host', '_assigned_flow', '_flow_per_area', '_min_flow_ratio',
+        '_min_flow_per_area', '_hmax_flow_ratio',
+    )
+
+    def __init__(
+        self, host, assigned_flow=None, flow_per_area=None, min_flow_ratio=None,
+        min_flow_per_area=None, hmax_flow_ratio=None
+    ):
+        """Initialize Room2D DOE-2 properties."""
+        # set the main properties of the Room2D
+        self._host = host
+        self.assigned_flow = assigned_flow
+        self.flow_per_area = flow_per_area
+        self.min_flow_ratio = min_flow_ratio
+        self.min_flow_per_area = min_flow_per_area
+        self.hmax_flow_ratio = hmax_flow_ratio
+
+    @property
+    def host(self):
+        """Get the Room2D object hosting these properties."""
+        return self._host
+
+    @property
+    def assigned_flow(self):
+        """Get or set the design supply air flow rate for the zone (cfm)."""
+        return self._assigned_flow
+
+    @assigned_flow.setter
+    def assigned_flow(self, value):
+        if value is not None:
+            value = float_positive(value, 'zone assigned flow')
+        self._assigned_flow = value
+
+    @property
+    def flow_per_area(self):
+        """Get or set the design supply air flow rate per unit floor area (cfm/ft2).
+        """
+        return self._flow_per_area
+
+    @flow_per_area.setter
+    def flow_per_area(self, value):
+        if value is not None:
+            value = float_positive(value, 'zone flow per area')
+        self._flow_per_area = value
+
+    @property
+    def min_flow_ratio(self):
+        """Get or set the the min supply airflow rate as a fraction of design flow rate.
+        """
+        return self._min_flow_ratio
+
+    @min_flow_ratio.setter
+    def min_flow_ratio(self, value):
+        if value is not None:
+            value = float_in_range(value, 0.0, 1.0, 'zone min flow ratio')
+        self._min_flow_ratio = value
+
+    @property
+    def min_flow_per_area(self):
+        """Get or set the minimum air flow per square foot of floor area (cfm/ft2)."""
+        return self._min_flow_per_area
+
+    @min_flow_per_area.setter
+    def min_flow_per_area(self, value):
+        if value is not None:
+            value = float_positive(value, 'zone min flow per area')
+        self._min_flow_per_area = value
+
+    @property
+    def hmax_flow_ratio(self):
+        """Get or set the ratio of the maximum heating airflow to the cooling airflow.
+        """
+        return self._hmax_flow_ratio
+
+    @hmax_flow_ratio.setter
+    def hmax_flow_ratio(self, value):
+        if value is not None:
+            value = float_in_range(value, 0.0, 1.0, 'zone heating max flow ratio')
+        self._hmax_flow_ratio = value
+
+    def check_floor_plate_vertex_count(self, raise_exception=True, detailed=False):
+        """Check whether the Room2D's floor geometry exceeds the maximum vertex count.
+
+        The DOE-2 engine currently does not support such rooms and limits the
+        total number of vertices to 120.
+
+        Args:
+            raise_exception: If True, a ValueError will be raised if the Room2D
+                floor plate exceeds the maximum number of vertices supported by
+                DOE-2. (Default: True).
+            detailed: Boolean for whether the returned object is a detailed list of
+                dicts with error info or a string with a message. (Default: False).
+
+        Returns:
+            A string with the message or a list with a dictionary if detailed is True.
+        """
+        if len(self.host.floor_geometry.boundary) > 120:
+            msg = 'Room2D "{}" has a floor plate with {} vertices, which is more ' \
+                'than the maximum 120 vertices supported by DOE-2.'.format(
+                    self.host.display_name, len(self.host.floor_geometry.boundary))
+            if raise_exception:
+                raise ValueError(msg)
+            full_msg = self.host._validation_message_child(
+                msg, self.host, detailed, '030101', extension='DOE2',
+                error_type='Room Exceeds Maximum Vertex Count')
+            if detailed:
+                return [full_msg]
+            if raise_exception:
+                raise ValueError(full_msg)
+            return full_msg
+        return [] if detailed else ''
+
+    def check_no_floor_plate_holes(self, raise_exception=True, detailed=False):
+        """Check whether the Room2D's floor geometry has holes.
+
+        EQuest currently has no way to represent such rooms so, if the issue
+        is not addressed, the hole will simply be removed as part of the
+        process of exporting to an INP file.
+
+        Args:
+            raise_exception: If True, a ValueError will be raised if the Room2D
+                floor plate has one or more holes. (Default: True).
+            detailed: Boolean for whether the returned object is a detailed list of
+                dicts with error info or a string with a message. (Default: False).
+
+        Returns:
+            A string with the message or a list with a dictionary if detailed is True.
+        """
+        if self.host.floor_geometry.has_holes:
+            hole_count = len(self.host.floor_geometry.holes)
+            hole_msg = 'a hole' if hole_count == 1 else '{} holes'.format(hole_count)
+            msg = 'Room2D "{}" has a floor plate with {}, which the eQuest ' \
+                'interface cannot represent.'.format(self.host.display_name, hole_msg)
+            if raise_exception:
+                raise ValueError(msg)
+            full_msg = self.host._validation_message_child(
+                msg, self.host, detailed, '030102', extension='DOE2',
+                error_type='Room Contains Holes')
+            if detailed:
+                return [full_msg]
+            if raise_exception:
+                raise ValueError(full_msg)
+            return full_msg
+        return [] if detailed else ''
+
+    @classmethod
+    def from_dict(cls, data, host):
+        """Create Room2DDoe2Properties from a dictionary.
+
+        Args:
+            data: A dictionary representation of Room2DDoe2Properties with the
+                format below.
+            host: A Room2D object that hosts these properties.
+
+        .. code-block:: python
+
+            {
+            "type": 'Room2DDoe2Properties',
+            "assigned_flow": 100,  # number in cfm
+            "flow_per_area": 1,  # number in cfm/ft2
+            "min_flow_ratio": 0.3, # number between 0 and 1
+            "min_flow_per_area": 0.3, # number in cfm/ft2
+            "hmax_flow_ratio": 0.3  # number between 0 and 1
+            }
+        """
+        assert data['type'] == 'Room2DDoe2Properties', \
+            'Expected Room2DDoe2Properties. Got {}.'.format(data['type'])
+        new_prop = cls(host)
+        auto_dict = autocalculate.to_dict()
+        if 'assigned_flow' in data and data['assigned_flow'] != auto_dict:
+            new_prop.assigned_flow = data['assigned_flow']
+        if 'flow_per_area' in data and data['flow_per_area'] != auto_dict:
+            new_prop.flow_per_area = data['flow_per_area']
+        if 'min_flow_ratio' in data and data['min_flow_ratio'] != auto_dict:
+            new_prop.min_flow_ratio = data['min_flow_ratio']
+        if 'min_flow_per_area' in data and data['min_flow_per_area'] != auto_dict:
+            new_prop.min_flow_per_area = data['min_flow_per_area']
+        if 'hmax_flow_ratio' in data and data['hmax_flow_ratio'] != auto_dict:
+            new_prop.hmax_flow_ratio = data['hmax_flow_ratio']
+        return new_prop
+
+    def apply_properties_from_dict(self, data):
+        """Apply properties from a Room2DDoe2Properties dictionary.
+
+        Args:
+            data: A Room2DDoe2Properties dictionary (typically coming from a Model).
+        """
+        auto_dict = autocalculate.to_dict()
+        if 'assigned_flow' in data and data['assigned_flow'] != auto_dict:
+            self.assigned_flow = data['assigned_flow']
+        if 'flow_per_area' in data and data['flow_per_area'] != auto_dict:
+            self.flow_per_area = data['flow_per_area']
+        if 'min_flow_ratio' in data and data['min_flow_ratio'] != auto_dict:
+            self.min_flow_ratio = data['min_flow_ratio']
+        if 'min_flow_per_area' in data and data['min_flow_per_area'] != auto_dict:
+            self.min_flow_per_area = data['min_flow_per_area']
+        if 'hmax_flow_ratio' in data and data['hmax_flow_ratio'] != auto_dict:
+            self.hmax_flow_ratio = data['hmax_flow_ratio']
+
+    def to_dict(self, abridged=False):
+        """Return Room2D Doe2 properties as a dictionary."""
+        base = {'doe2': {}}
+        base['doe2']['type'] = 'Room2DDoe2Properties'
+        if self.assigned_flow is not None:
+            base['doe2']['assigned_flow'] = self.assigned_flow
+        if self.flow_per_area is not None:
+            base['doe2']['flow_per_area'] = self.flow_per_area
+        if self.min_flow_ratio is not None:
+            base['doe2']['min_flow_ratio'] = self.min_flow_ratio
+        if self.min_flow_per_area is not None:
+            base['doe2']['min_flow_per_area'] = self.min_flow_per_area
+        if self.hmax_flow_ratio is not None:
+            base['doe2']['hmax_flow_ratio'] = self.hmax_flow_ratio
+        return base
+
+    def to_honeybee(self, new_host):
+        """Get a honeybee version of this object.
+
+        Args:
+            new_host: A honeybee-core Room object that will host these properties.
+        """
+        return RoomDoe2Properties(
+            new_host, self.assigned_flow, self.flow_per_area, self.min_flow_ratio,
+            self.min_flow_per_area, self.hmax_flow_ratio
+        )
+
+    def from_honeybee(self, hb_properties):
+        """Transfer Doe-2 attributes from a Honeybee Room to Dragonfly Room2D.
+
+        Args:
+            hb_properties: The RoomDoe2Properties of the honeybee Room that is being
+                translated to a Dragonfly Room2D.
+        """
+        self._assigned_flow = hb_properties._assigned_flow
+        self._flow_per_area = hb_properties._flow_per_area
+        self._min_flow_ratio = hb_properties._min_flow_ratio
+        self._min_flow_per_area = hb_properties._min_flow_per_area
+        self._hmax_flow_ratio = hb_properties._hmax_flow_ratio
+
+    def duplicate(self, new_host=None):
+        """Get a copy of this object.
+
+        Args:
+            new_host: A new Room2D object that hosts these properties.
+                If None, the properties will be duplicated with the same host.
+        """
+        _host = new_host or self._host
+        new_room = Room2DDoe2Properties(
+            _host, self.assigned_flow, self.flow_per_area, self.min_flow_ratio,
+            self.min_flow_per_area, self.hmax_flow_ratio)
+        return new_room
+
+    def ToString(self):
+        return self.__repr__()
+
+    def __repr__(self):
+        return 'Room2D DOE2 Properties: [host: {}]'.format(self.host.display_name)

dragonfly_doe2/writer.py

@@ -0,0 +1,129 @@
+# coding: utf-8
+"""Write an inp file from a Dragonfly model."""
+from __future__ import division
+
+from honeybee_doe2.writer import model_to_inp as hb_model_to_inp
+
+
+def model_to_inp(
+    model, use_multiplier=True, exclude_plenums=False, solve_ceiling_adjacencies=True,
+    simulation_par=None, hvac_mapping='Story',
+    exclude_interior_walls=False, exclude_interior_ceilings=False, equest_version=None
+):
+    """Generate an INP string from a Dragonfly Model.
+
+    The resulting string will include all geometry, all fully-detailed constructions
+    and materials, all fully-detailed schedules, and the room properties. It will
+    also include the simulation parameters. Essentially, the string includes
+    everything needed to simulate the model.
+
+    Args:
+        model: A dragonfly Model for which an INP representation will be returned.
+        use_multiplier: Boolean to note if the multipliers on each Building
+            story will be passed along to the generated Honeybee Room objects
+            or if full geometry objects should be written for each story in the
+            building. (Default: True).
+        exclude_plenums: Boolean to indicate whether ceiling/floor plenum depths
+            assigned to Room2Ds should generate distinct 3D Rooms in the
+            translation. (Default: False).
+        solve_ceiling_adjacencies: Boolean to indicate whether adjacencies should
+            be solved between interior stories when Room2Ds perfectly match one
+            another in their floor plate. This ensures that Surface boundary
+            conditions are used instead of Adiabatic ones. (Default: True).
+        simulation_par: A honeybee-doe2 SimulationPar object to specify how the
+            DOE-2 simulation should be run. If None, default simulation
+            parameters will be generated, which will run the simulation for the
+            full year. (Default: None).
+        hvac_mapping: Text to indicate how HVAC systems should be assigned to the
+            exported model. Story will assign one HVAC system for each distinct
+            level polygon, Model will use only one HVAC system for the whole model
+            and AssignedHVAC will follow how the HVAC systems have been assigned
+            to the Rooms.properties.energy.hvac. Choose from the options
+            below. (Default: Story).
+
+            * Room
+            * Story
+            * Model
+            * AssignedHVAC
+
+        exclude_interior_walls: Boolean to note whether interior wall Faces
+            should be excluded from the resulting string. (Default: False).
+        exclude_interior_ceilings: Boolean to note whether interior ceiling
+            Faces should be excluded from the resulting string. (Default: False).
+        equest_version: An optional text string to denote the version of eQuest
+            for which the INP definition will be generated. If unspecified
+            or unrecognized, the latest version of eQuest will be used.
+
+    Usage:
+
+    .. code-block:: python
+
+        import os
+        from ladybug.futil import write_to_file
+        from ladybug_geometry.geometry3d import Point3D, Face3D
+        from dragonfly.model import Model
+        from dragonfly.building import Building
+        from dragonfly.story import Story
+        from dragonfly.room2d import Room2D
+        from dragonfly.roof import RoofSpecification
+        from dragonfly.windowparameter import SimpleWindowRatio
+        from honeybee.config import folders
+
+        # Crate an input Model
+        pts1 = (Point3D(0, 0, 0), Point3D(10, 0, 0),
+                Point3D(10, 10, 0), Point3D(0, 10, 0))
+        pts2 = (Point3D(10, 0, 0), Point3D(20, 0, 0),
+                Point3D(20, 10, 0), Point3D(10, 10, 0))
+        pts3 = (Point3D(0, 0, 3.25), Point3D(20, 0, 3.25),
+                Point3D(20, 5, 5), Point3D(0, 5, 5))
+        pts4 = (Point3D(0, 5, 5), Point3D(20, 5, 5),
+                Point3D(20, 10, 3.25), Point3D(0, 10, 3.25))
+        room2d_full = Room2D(
+            'R1-full', floor_geometry=Face3D(pts1), floor_to_ceiling_height=4,
+            is_ground_contact=True, is_top_exposed=True)
+        room2d_plenum = Room2D(
+            'R2-plenum', floor_geometry=Face3D(pts2), floor_to_ceiling_height=4,
+            is_ground_contact=True, is_top_exposed=True)
+        room2d_plenum.ceiling_plenum_depth = 1.0
+        roof = RoofSpecification([Face3D(pts3), Face3D(pts4)])
+        story = Story('S1', [room2d_full, room2d_plenum])
+        story.roof = roof
+        story.solve_room_2d_adjacency(0.01)
+        story.set_outdoor_window_parameters(SimpleWindowRatio(0.4))
+        building = Building('Office_Building_1234', [story])
+        model = Model('NewDevelopment1', [building])
+
+        # create the INP string for the model
+        inp_str = model.to.inp(model)
+
+        # write the final string into an INP
+        inp = os.path.join(folders.default_simulation_folder, 'test_file', 'in.inp')
+        write_to_file(inp, inp_str, True)
+    """
+    # convert the Dragonfly Model to Honeybee
+    hb_model = model.to_honeybee(
+        'District', use_multiplier=use_multiplier, exclude_plenums=exclude_plenums,
+        solve_ceiling_adjacencies=solve_ceiling_adjacencies,
+        enforce_adj=False, enforce_solid=True)[0]
+
+    # assign the space polygon geometry to the Honeybee Rooms from Dragonfly
+    df_flr_geos = {}  # dictionary to hold the DOE-2 space polygon geometry
+    for df_room in model.room_2ds:
+        df_flr_geos[df_room.identifier] = df_room.floor_geometry
+    for hb_room in hb_model.rooms:
+        try:
+            hb_room.properties.doe2.space_polygon_geometry = \
+                df_flr_geos[hb_room.identifier]
+        except KeyError:  # possibly a 3D Room that has no Room2D geometry
+            pass
+
+    # patch missing adjacencies to adiabatic in case the models is a sub-selection
+    hb_model.properties.energy.missing_adjacencies_to_adiabatic()
+
+    # translate the Honeybee Model to INP
+    inp_str = hb_model_to_inp(
+        hb_model, simulation_par=simulation_par, hvac_mapping=hvac_mapping,
+        exclude_interior_walls=exclude_interior_walls,
+        exclude_interior_ceilings=exclude_interior_ceilings,
+        equest_version=equest_version)
+    return inp_str

dragonfly_doe2-0.12.9.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: dragonfly-doe2
+Version: 0.12.9
+Summary: Dragonfly extension for the DOE-2 energy simulation engine.
+Home-page: https://github.com/ladybug-tools/dragonfly-doe2
+Author: Ladybug Tools
+Author-email: info@ladybug.tools
+License: AGPL-3.0
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: IronPython
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: honeybee-doe2==0.23.1
+Requires-Dist: dragonfly-energy>=1.34.72
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+![Dragonfly](https://www.ladybug.tools/assets/img/dragonfly.png) ![DOE-2](https://doe2.com/DOE2/BldgDOE2.gif) ![eQuest](https://www.doe2.com/equest/eQcb_142.gif)
+
+[![Build Status](https://github.com/ladybug-tools/dragonfly-doe2/actions/workflows/ci.yaml/badge.svg)](https://github.com/ladybug-tools/dragonfly-doe2/actions)
+
+[![Python 3.10](https://img.shields.io/badge/python-3.10-orange.svg)](https://www.python.org/downloads/release/python-3100/) [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)
+
+# dragonfly-doe2
+
+Dragonfly extension for energy modeling with the DOE-2 engine.
+
+[DOE-2](https://www.doe2.com/) is a widely used and accepted freeware building energy analysis program that can predict the energy use and cost for all types of buildings. It is the engine under the hood of the [eQuest](https://www.doe2.com/equest/) interface.
+
+## Installation
+
+`pip install -U dragonfly-doe2`
+
+To check if the command line interface is installed correctly
+use `dragonfly-doe2 --help`.
+
+## QuickStart
+
+```console
+import dragonfly_doe2
+```
+
+## [API Documentation](http://ladybug-tools.github.io/dragonfly-doe2/docs)
+
+## Local Development
+
+1. Clone this repo locally
+```console
+git clone git@github.com:ladybug-tools/dragonfly-doe2
+
+# or
+
+git clone https://github.com/ladybug-tools/dragonfly-doe2
+```
+2. Install dependencies:
+```
+cd dragonfly-doe2
+pip install -r dev-requirements.txt
+pip install -r requirements.txt
+```
+
+3. Run Tests:
+```console
+python -m pytest tests/
+```
+
+4. Generate Documentation:
+```console
+sphinx-apidoc -f -e -d 4 -o ./docs ./dragonfly_doe2
+sphinx-build -b html ./docs ./docs/_build/docs
+```

dragonfly_doe2-0.12.9.dist-info/RECORD

@@ -0,0 +1,15 @@
+dragonfly_doe2/__init__.py,sha256=Fg3aP_2h6-UD4bqHbFJ3tMbA_ZED5uDGjDedY4XJp8g,40
+dragonfly_doe2/__main__.py,sha256=3FrW6CO-CPoGSXn73hLWCejb0d-qnit6ga_565z49uY,75
+dragonfly_doe2/_extend_dragonfly.py,sha256=_3XebNYHxG__7wxLOtW-aqPV-OIkplvVXgnBEDgrcS0,996
+dragonfly_doe2/writer.py,sha256=Yfs9fEEhX8WrDqhy4nIxeOwMPDKHvu3RoeInz94pGO8,6224
+dragonfly_doe2/cli/__init__.py,sha256=OwTHSsOOEoJjbw5CqPig8Yo7jk1f6m53OFnhuZgPthE,391
+dragonfly_doe2/cli/translate.py,sha256=gVpMSL074B6YPOe26cD0njGL_durS9lugrenbLoZiUw,7989
+dragonfly_doe2/properties/__init__.py,sha256=0JiyMYGeRlPLcxh1PSr6eJzDGgfrbMivcO9dS1h7wEU,33
+dragonfly_doe2/properties/model.py,sha256=UGZdCvWyxx8NfYxhjA6fFgwGDpG0P9dbUANQjNvRhpM,14549
+dragonfly_doe2/properties/room2d.py,sha256=ghKKhcX2TSgPUAdcQk-PPHo_5AilSmTiLElxb8--dkE,12773
+dragonfly_doe2-0.12.9.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+dragonfly_doe2-0.12.9.dist-info/METADATA,sha256=mdb6wjDa6F7yelGhyf3Iii6CymE-UGUK1Tgnx2Lq8vQ,3102
+dragonfly_doe2-0.12.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dragonfly_doe2-0.12.9.dist-info/entry_points.txt,sha256=oBzZOsc8Bs40iHKtuyWGrz_nfLZu1-6cHrBej05ZqrY,59
+dragonfly_doe2-0.12.9.dist-info/top_level.txt,sha256=6CLCvUyl1H2vrbXmeA0ND_znFz4a2oOclc7NMBZxR6c,15
+dragonfly_doe2-0.12.9.dist-info/RECORD,,

dragonfly_doe2-0.12.9.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dragonfly_doe2-0.12.9.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dragonfly-doe2 = dragonfly_doe2.cli:doe2