zepben.ewb 1.0.0b1__py3-none-any.whl

zepben/ewb/model/cim/iec61968/infiec61968/infassets/streetlight_lamp_kind.py

@@ -0,0 +1,25 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["StreetlightLampKind"]
+
+from enum import Enum, unique
+
+
+@unique
+class StreetlightLampKind(Enum):
+    """
+    Kind of lamp for a `Streetlight`
+    """
+
+    UNKNOWN = 0
+    HIGH_PRESSURE_SODIUM = 1
+    MERCURY_VAPOR = 2
+    METAL_HALIDE = 3
+    OTHER = 4
+
+    @property
+    def short_name(self):
+        return str(self)[20:]

zepben/ewb/model/cim/iec61968/infiec61968/infcommon/__init__.py

@@ -0,0 +1,4 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.

zepben/ewb/model/cim/iec61968/infiec61968/infcommon/ratio.py

@@ -0,0 +1,34 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["Ratio"]
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Ratio:
+    """
+    Fraction specified explicitly with a numerator and denominator, which can be used to calculate the quotient.
+    """
+
+    numerator: float
+    """The part of a fraction that is below the line and that functions as the divisor of the numerator."""
+
+    denominator: float
+    """The part of a fraction that is above the line and signifies the number to be divided by the denominator."""
+
+    @property
+    def quotient(self) -> float:
+        """
+        The result of dividing the numerator by the denominator.
+
+        :return: The quotient of this ``Ratio``.
+        :raises AttributeError: If the denominator of this ``Ratio`` is zero.
+        """
+        if self.denominator == 0:
+            raise AttributeError("Cannot calculate the quotient of a Ratio with a denominator of zero.")
+
+        return self.numerator / self.denominator

zepben/ewb/model/cim/iec61968/metering/__init__.py

@@ -0,0 +1,4 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.

zepben/ewb/model/cim/iec61968/metering/controlled_appliance.py

@@ -0,0 +1,150 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ["ControlledAppliance", "Appliance"]
+
+from dataclasses import dataclass
+from enum import Enum, unique
+from typing import List, Union
+
+
+@unique
+class Appliance(Enum):
+    """
+    The type of appliance.
+    """
+
+    ELECTRIC_VEHICLE = 0
+    """An electric vehicle."""
+
+    EXTERIOR_LIGHTING = 1
+    """Exterior lighting."""
+
+    GENERATION_SYSTEM = 2
+    """A generation system."""
+
+    HVAC_COMPRESSOR_OR_FURNACE = 3
+    """HVAC compressor or furnace."""
+
+    INTERIOR_LIGHTING = 4
+    """Interior lighting."""
+
+    IRRIGATION_PUMP = 5
+    """An irrigation pump."""
+
+    MANAGED_COMMERCIAL_INDUSTRIAL_LOAD = 6
+    """Managed commercial or industrial load."""
+
+    POOL_PUMP_SPA_JACUZZI = 7
+    """A pool, pump, spa or jacuzzi."""
+
+    SIMPLE_MISC_LOAD = 8
+    """A simple miscellaneous load."""
+
+    SMART_APPLIANCE = 9
+    """A smart appliance."""
+
+    STRIP_AND_BASEBOARD_HEATER = 10
+    """A strip or baseboard heater."""
+
+    WATER_HEATER = 11
+    """A water heater."""
+
+    @property
+    def bitmask(self):
+        return 1 << self.value
+
+
+@dataclass
+class ControlledAppliance:
+    """
+    Appliance controlled with a PAN device control.
+    """
+
+    _bitmask: int
+
+    def __init__(self, appliances: Union[int, Appliance, List[Appliance]]):
+        if isinstance(appliances, int):
+            self._bitmask = appliances
+        elif isinstance(appliances, Appliance):
+            self._bitmask = appliances.bitmask
+        elif isinstance(appliances, List):
+            if appliances:
+                def f(bitmask: int, nxt: Appliance) -> int:
+                    return bitmask | nxt.bitmask
+
+                acc = appliances[0].bitmask
+                if len(appliances) > 1:
+                    _ = [acc := f(acc, app) for app in appliances[1:]]
+                self._bitmask = acc
+
+    @property
+    def bitmask(self):
+        return self._bitmask
+
+    @property
+    def is_electric_vehicle(self) -> bool:
+        """True if the appliance is an electric vehicle"""
+        return Appliance.ELECTRIC_VEHICLE in self
+
+    @property
+    def is_exterior_lighting(self) -> bool:
+        """True if the appliance is exterior lighting"""
+        return Appliance.EXTERIOR_LIGHTING in self
+
+    @property
+    def is_generation_system(self) -> bool:
+        """True if the appliance is a generation system"""
+        return Appliance.GENERATION_SYSTEM in self
+
+    @property
+    def is_hvac_compressor_or_furnace(self) -> bool:
+        """True if the appliance is HVAC compressor or furnace"""
+        return Appliance.HVAC_COMPRESSOR_OR_FURNACE in self
+
+    @property
+    def is_interior_lighting(self) -> bool:
+        """True if the appliance is interior lighting"""
+        return Appliance.INTERIOR_LIGHTING in self
+
+    @property
+    def is_irrigation_pump(self) -> bool:
+        """True if the appliance is an irrigation pump"""
+        return Appliance.IRRIGATION_PUMP in self
+
+    @property
+    def is_managed_commercial_industrial_load(self) -> bool:
+        """True if the appliance is managed commercial or industrial load"""
+        return Appliance.MANAGED_COMMERCIAL_INDUSTRIAL_LOAD in self
+
+    @property
+    def is_pool_pump_spa_jacuzzi(self) -> bool:
+        """True if the appliance is a pool, pump, spa or jacuzzi"""
+        return Appliance.POOL_PUMP_SPA_JACUZZI in self
+
+    @property
+    def is_simple_misc_load(self) -> bool:
+        """True if the appliance is a simple miscellaneous load"""
+        return Appliance.SIMPLE_MISC_LOAD in self
+
+    @property
+    def is_smart_appliance(self) -> bool:
+        """True if the appliance is a smart appliance"""
+        return Appliance.SMART_APPLIANCE in self
+
+    @property
+    def is_strip_and_baseboard_heater(self) -> bool:
+        """True if the appliance is a strip or baseboard heater"""
+        return Appliance.STRIP_AND_BASEBOARD_HEATER in self
+
+    @property
+    def is_water_heater(self) -> bool:
+        """True if the appliance is a water heater"""
+        return Appliance.WATER_HEATER in self
+
+    def __contains__(self, item: Appliance):
+        return (self._bitmask & item.bitmask) != 0

zepben/ewb/model/cim/iec61968/metering/end_device.py

@@ -0,0 +1,165 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ["EndDevice"]
+
+from typing import Optional, List, Generator, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61968.assets.asset_container import AssetContainer
+from zepben.ewb.util import nlen, ngen, get_by_mrid, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61968.common.location import Location
+    from zepben.ewb.model.cim.iec61968.metering.end_device_function import EndDeviceFunction
+    from zepben.ewb.model.cim.iec61968.metering.usage_point import UsagePoint
+
+
+class EndDevice(AssetContainer):
+    """
+    Asset container that performs one or more end device functions. One type of end device is a meter which can perform
+    metering, load management, connect/disconnect, accounting functions, etc. Some end devices, such as ones monitoring
+    and controlling air conditioners, refrigerators, pool pumps may be connected to a meter. All end devices may have
+    communication capability defined by the associated communication function(s).
+
+    An end device may be owned by a consumer, a service provider, utility or otherwise.
+
+    There may be a related end device function that identifies a sensor or control point within a metering application
+    or communications systems (e.g., water, gas, electricity).
+
+    Some devices may use an optical port that conforms to the ANSI C12.18 standard for communications.
+    """
+
+    customer_mrid: Optional[str] = None
+    """The `zepben.ewb.model.cim.iec61968.customers.customer.Customer` owning this `EndDevice`."""
+
+    service_location: Optional[Location] = None
+    """Service `zepben.ewb.model.cim.iec61968.common.location.Location` whose service delivery is measured by this `EndDevice`."""
+
+    _usage_points: Optional[List[UsagePoint]] = None
+
+    _functions: Optional[List[EndDeviceFunction]] = None
+
+    def __init__(self, usage_points: List[UsagePoint] = None, functions: List[EndDeviceFunction] = None, **kwargs):
+        super(EndDevice, self).__init__(**kwargs)
+        if usage_points:
+            for up in usage_points:
+                self.add_usage_point(up)
+        if functions:
+            for edf in functions:
+                self.add_function(edf)
+
+    def num_usage_points(self):
+        """
+        Returns The number of `UsagePoint`s associated with this `EndDevice`
+        """
+        return nlen(self._usage_points)
+
+    @property
+    def usage_points(self) -> Generator[UsagePoint, None, None]:
+        """
+        The `UsagePoint`s associated with this `EndDevice`
+        """
+        return ngen(self._usage_points)
+
+    def get_usage_point(self, mrid: str) -> UsagePoint:
+        """
+        Get the `UsagePoint` for this `EndDevice` identified by `mrid`
+
+        `mrid` the mRID of the required `UsagePoint`
+        Returns The `UsagePoint` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._usage_points, mrid)
+
+    def add_usage_point(self, up: UsagePoint) -> EndDevice:
+        """
+        Associate `up` to this `EndDevice`.
+
+        `up` the `UsagePoint` to associate with this `EndDevice`.
+        Returns A reference to this `EndDevice` to allow fluent use.
+        Raises `ValueError` if another `UsagePoint` with the same `mrid` already exists for this `EndDevice`.
+        """
+        if self._validate_reference(up, self.get_usage_point, "A UsagePoint"):
+            return self
+        self._usage_points = list() if self._usage_points is None else self._usage_points
+        self._usage_points.append(up)
+        return self
+
+    def remove_usage_point(self, up: UsagePoint) -> EndDevice:
+        """
+        Disassociate `up` from this `EndDevice`
+
+        `up` the `UsagePoint` to disassociate from this `EndDevice`.
+        Returns A reference to this `EndDevice` to allow fluent use.
+        Raises `ValueError` if `up` was not associated with this `EndDevice`.
+        """
+        self._usage_points = safe_remove(self._usage_points, up)
+        return self
+
+    def clear_usage_points(self) -> EndDevice:
+        """
+        Clear all usage_points.
+        Returns A reference to this `EndDevice` to allow fluent use.
+        """
+        self._usage_points = None
+        return self
+
+    def num_functions(self):
+        """
+        Returns The number of `EndDeviceFunction`s associated with this `EndDevice`
+        """
+        return nlen(self._functions)
+
+    @property
+    def functions(self) -> Generator[EndDeviceFunction, None, None]:
+        """
+        The `EndDeviceFunction`s associated with this `EndDevice`
+        """
+        return ngen(self._functions)
+
+    def get_function(self, mrid: str) -> EndDeviceFunction:
+        """
+        Get the `EndDeviceFunction` for this `EndDevice` identified by `mrid`
+
+        `mrid` the mRID of the required `EndDeviceFunction`
+        Returns The `EndDeviceFunction` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._functions, mrid)
+
+    def add_function(self, edf: EndDeviceFunction) -> EndDevice:
+        """
+        Associate `edf` to this `EndDevice`.
+
+        `edf` the `EndDeviceFunction` to associate with this `EndDevice`.
+        Returns A reference to this `EndDevice` to allow fluent use.
+        Raises `ValueError` if another `EndDeviceFunction` with the same `mrid` already exists for this `EndDevice`.
+        """
+        if self._validate_reference(edf, self.get_function, "An EndDeviceFunction"):
+            return self
+        self._functions = list() if self._functions is None else self._functions
+        self._functions.append(edf)
+        return self
+
+    def remove_function(self, edf: EndDeviceFunction) -> EndDevice:
+        """
+        Disassociate `edf` from this `EndDevice`
+
+        `up` the `EndDeviceFunction` to disassociate from this `EndDevice`.
+        Returns A reference to this `EndDevice` to allow fluent use.
+        Raises `ValueError` if `up` was not associated with this `EndDevice`.
+        """
+        self._functions = safe_remove(self._functions, edf)
+        return self
+
+    def clear_functions(self) -> EndDevice:
+        """
+        Clear all end_device_functions.
+        Returns A reference to this `EndDevice` to allow fluent use.
+        """
+        self._functions = None
+        return self

zepben/ewb/model/cim/iec61968/metering/end_device_function.py

@@ -0,0 +1,17 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["EndDeviceFunction"]
+
+from zepben.ewb.model.cim.iec61968.assets.asset_function import AssetFunction
+
+
+class EndDeviceFunction(AssetFunction):
+    """
+    Function performed by an end device such as a meter, communication equipment, controllers, etc.
+    """
+
+    enabled: bool = True
+    """True if the function is enabled."""

zepben/ewb/model/cim/iec61968/metering/end_device_function_kind.py

@@ -0,0 +1,46 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["EndDeviceFunctionKind"]
+
+from enum import Enum, unique
+
+
+@unique
+class EndDeviceFunctionKind(Enum):
+    """
+    Kind of end device function.
+    """
+
+    UNKNOWN = 0
+    """Unknown function kind."""
+
+    autonomousDst = 1
+    """Autonomous application of daylight saving time (DST)."""
+
+    demandResponse = 2
+    """Demand response functions."""
+
+    electricMetering = 3
+    """Electricity metering."""
+
+    metrology = 4
+    """Presentation of metered values to a user or another system (always a function of a meter, but might not be supported by a load control unit)."""
+
+    onRequestRead = 5
+    """On-request reads."""
+
+    outageHistory = 6
+    """Reporting historical power interruption data."""
+
+    relaysProgramming = 7
+    """Support for one or more relays that may be programmable in the meter (and tied to TOU, time pulse, load control or other functions)."""
+
+    reverseFlow = 8
+    """Detection and monitoring of reverse flow."""
+
+    @property
+    def short_name(self):
+        return str(self)[22:]

zepben/ewb/model/cim/iec61968/metering/meter.py

@@ -0,0 +1,26 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+__all__ = ["Meter"]
+
+from zepben.ewb.model.cim.iec61968.metering.end_device import EndDevice
+
+
+class Meter(EndDevice):
+    """
+    Physical asset that performs the metering role of the usage point. Used for measuring consumption and detection of events.
+    """
+
+    @property
+    def company_meter_id(self):
+        """ Returns this `Meter`s ID. Currently stored in `IdentifiedObject.name` """
+        return self.name
+
+    @company_meter_id.setter
+    def company_meter_id(self, meter_id):
+        """
+        `meter_id` The ID to set for this Meter. Will use `IdentifiedObject.name` as a backing field.
+        """
+        self.name = meter_id

zepben/ewb/model/cim/iec61968/metering/usage_point.py

@@ -0,0 +1,186 @@
+#  Copyright 2025 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from __future__ import annotations
+
+__all__ = ["UsagePoint"]
+
+from typing import Optional, List, Generator, TYPE_CHECKING
+
+from zepben.ewb.model.cim.iec61970.base.core.identified_object import IdentifiedObject
+from zepben.ewb.model.cim.iec61970.base.core.phase_code import PhaseCode
+from zepben.ewb.util import nlen, ngen, get_by_mrid, safe_remove
+
+if TYPE_CHECKING:
+    from zepben.ewb.model.cim.iec61968.common.location import Location
+    from zepben.ewb.model.cim.iec61968.metering.end_device import EndDevice
+    from zepben.ewb.model.cim.iec61970.base.core.equipment import Equipment
+
+
+class UsagePoint(IdentifiedObject):
+    """
+    Logical or physical point in the network to which readings or events may be attributed.
+    Used at the place where a physical or virtual meter may be located; however, it is not required that a meter be present.
+    """
+
+    usage_point_location: Optional[Location] = None
+    """Service `zepben.ewb.model.cim.iec61968.common.location.Location` where the service delivered by this `UsagePoint` is consumed."""
+
+    is_virtual: bool = False
+    """
+    If true, this usage point is virtual, i.e., no physical location exists in the network where a meter could be located to
+    collect the meter readings. For example, one may define a virtual usage point to serve as an aggregation of usage for all
+    of a company's premises distributed widely across the distribution territory. Otherwise, the usage point is physical,
+    i.e., there is a logical point in the network where a meter could be located to collect meter readings.
+    """
+
+    connection_category: Optional[str] = None
+    """
+    A code used to specify the connection category, e.g., low voltage or low pressure, where the usage point is defined.
+    """
+
+    rated_power: Optional[int] = None
+    """Active power that this usage point is configured to deliver in watts."""
+
+    approved_inverter_capacity: Optional[int] = None
+    """The approved inverter capacity at this UsagePoint in volt-amperes."""
+
+    phase_code: PhaseCode = PhaseCode.NONE
+    """
+    Phase code. Number of wires and specific nominal phases can be deduced from enumeration literal values. For example, ABCN is three-phase,
+    four-wire, s12n (splitSecondary12N) is single-phase, three-wire, and s1n and s2n are single-phase, two-wire.
+    """
+
+    _equipment: Optional[List[Equipment]] = None
+    _end_devices: Optional[List[EndDevice]] = None
+
+    def __init__(self, equipment: List[Equipment] = None, end_devices: List[EndDevice] = None, **kwargs):
+        super(UsagePoint, self).__init__(**kwargs)
+        if equipment:
+            for eq in equipment:
+                self.add_equipment(eq)
+        if end_devices:
+            for ed in end_devices:
+                self.add_end_device(ed)
+
+    def num_equipment(self):
+        """
+        Returns The number of `Equipment`s associated with this `UsagePoint`
+        """
+        return nlen(self._equipment)
+
+    def num_end_devices(self):
+        """
+        Returns The number of `EndDevice`s associated with this `UsagePoint`
+        """
+        return nlen(self._end_devices)
+
+    @property
+    def end_devices(self) -> Generator[EndDevice, None, None]:
+        """
+        The `EndDevice`'s (Meter's) associated with this `UsagePoint`.
+        """
+        return ngen(self._end_devices)
+
+    @property
+    def equipment(self) -> Generator[Equipment, None, None]:
+        """
+        The `zepben.model.Equipment` associated with this `UsagePoint`.
+        """
+        return ngen(self._equipment)
+
+    def get_equipment(self, mrid: str) -> Equipment:
+        """
+        Get the `Equipment` for this `UsagePoint` identified by `mrid`
+
+        `mrid` The mRID of the required `Equipment`
+        Returns The `Equipment` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._equipment, mrid)
+
+    def add_equipment(self, equipment: Equipment) -> UsagePoint:
+        """
+        Associate an `Equipment` with this `UsagePoint`
+
+        `equipment` The `Equipment` to associate with this `UsagePoint`.
+        Returns A reference to this `UsagePoint` to allow fluent use.
+        Raises `ValueError` if another `Equipment` with the same `mrid` already exists for this `UsagePoint`.
+        """
+        if self._validate_reference(equipment, self.get_equipment, "An Equipment"):
+            return self
+
+        self._equipment = list() if self._equipment is None else self._equipment
+        self._equipment.append(equipment)
+        return self
+
+    def remove_equipment(self, equipment: Equipment) -> UsagePoint:
+        """
+        Disassociate an `Equipment` from this `UsagePoint`
+
+        `equipment` The `Equipment` to disassociate with this `UsagePoint`.
+        Returns A reference to this `UsagePoint` to allow fluent use.
+        Raises `ValueError` if `equipment` was not associated with this `UsagePoint`.
+        """
+        self._equipment = safe_remove(self._equipment, equipment)
+        return self
+
+    def clear_equipment(self) -> UsagePoint:
+        """
+        Clear all equipment.
+        Returns A reference to this `UsagePoint` to allow fluent use.
+        """
+        self._equipment = None
+        return self
+
+    def get_end_device(self, mrid: str) -> EndDevice:
+        """
+        Get the `EndDevice` for this `UsagePoint` identified by `mrid`
+
+        `mrid` The mRID of the required `EndDevice`
+        Returns The `EndDevice` with the specified `mrid` if it exists
+        Raises `KeyError` if `mrid` wasn't present.
+        """
+        return get_by_mrid(self._end_devices, mrid)
+
+    def add_end_device(self, end_device: EndDevice) -> UsagePoint:
+        """
+        Associate an `EndDevice` with this `UsagePoint`
+
+        `end_device` The `EndDevice` to associate with this `UsagePoint`.
+        Returns A reference to this `UsagePoint` to allow fluent use.
+        Raises `ValueError` if another `EndDevice` with the same `mrid` already exists for this `UsagePoint`.
+        """
+        if self._validate_reference(end_device, self.get_end_device, "An EndDevice"):
+            return self
+        self._end_devices = list() if self._end_devices is None else self._end_devices
+        self._end_devices.append(end_device)
+        return self
+
+    def remove_end_device(self, end_device: EndDevice) -> UsagePoint:
+        """
+        Disassociate `end_device` from this `UsagePoint`.
+
+        `end_device` The `EndDevice` to disassociate from this `UsagePoint`.
+        Returns A reference to this `UsagePoint` to allow fluent use.
+        Raises `ValueError` if `end_device` was not associated with this `UsagePoint`.
+        """
+        self._end_devices = safe_remove(self._end_devices, end_device)
+        return self
+
+    def clear_end_devices(self) -> UsagePoint:
+        """
+        Clear all end_devices.
+        Returns A reference to this `UsagePoint` to allow fluent use.
+        """
+        self._end_devices = None
+        return self
+
+    def is_metered(self):
+        """
+        Check whether this `UsagePoint` is metered. A `UsagePoint` is metered if it's associated with at least one `EndDevice`.
+        Returns True if this `UsagePoint` has an `EndDevice`, False otherwise.
+        """
+        return nlen(self._end_devices) > 0

zepben/ewb/model/cim/iec61968/operations/__init__.py

@@ -0,0 +1,4 @@
+#  Copyright 2024 Zeppelin Bend Pty Ltd
+#  This Source Code Form is subject to the terms of the Mozilla Public
+#  License, v. 2.0. If a copy of the MPL was not distributed with this
+#  file, You can obtain one at https://mozilla.org/MPL/2.0/.