Embed enums in their corresponding codecs (#5)

This undoes a change I made to bring all enums out into the bf_codecs module. We believe that this will allow users to have a better understanding of where the enums are intended to be used.

Author: velovix

brainframe/api/bf_codecs/__init__.py

@@ -5,27 +5,21 @@
     ZoneAlarmCountCondition,
     ZoneAlarmRateCondition,
     IntersectionPointType,
-    CountConditionTestType,
-    RateConditionTestType,
-    DirectionType,
 )
-from .config_codecs import StreamConfiguration, ConnType
+from .config_codecs import StreamConfiguration
 from .identity_codecs import Identity, Encoding
 from .detection_codecs import Attribute, Detection
 from .zone_codecs import Zone, ZoneStatus
 from .plugin_codecs import (
     PluginOption,
     Plugin,
     NodeDescription,
-    OptionType,
-    SizeType,
 )
 from .premises_codecs import Premises
-from .user_codecs import User, RoleType
+from .user_codecs import User
 from .license_codecs import (
     LicenseTerms,
     LicenseInfo,
     DATE_FORMAT,
-    LicenseState,
 )
 from .sorting import SortOptions, Ordering

brainframe/api/bf_codecs/base_codecs.py

@@ -9,7 +9,8 @@ class Codec(abc.ABC):
     def to_dict(self) -> dict:
         pass
 
-    @abc.abstractstaticmethod
+    @staticmethod
+    @abc.abstractmethod
     def from_dict(d: dict):
         pass
 

brainframe/api/bf_codecs/condition_codecs.py

@@ -15,21 +15,6 @@
                       "!=": "Not Equal To"}
 
 
-class CountConditionTestType(Enum):
-    """Defines the way a count condition compares the actual value to the
-    alarm's test value.
-    """
-
-    GREATER_THAN = ">"
-    LESS_THAN = "<"
-    EQUAL_TO = "="
-    NOT_EQUAL_TO = "!="
-
-    @classmethod
-    def values(cls):
-        return [v.value for v in cls]
-
-
 class IntersectionPointType(Enum):
     """The point on a detection that must be inside a zone for the detection to
     count as being inside the zone. The most commonly used intersection point
@@ -54,7 +39,21 @@ class ZoneAlarmCountCondition(Codec):
     of objects in a zone to some number.
     """
 
-    test: CountConditionTestType
+    class TestType(Enum):
+        """Defines the way a count condition compares the actual value to the
+        alarm's test value.
+        """
+
+        GREATER_THAN = ">"
+        LESS_THAN = "<"
+        EQUAL_TO = "="
+        NOT_EQUAL_TO = "!="
+
+        @classmethod
+        def values(cls):
+            return [v.value for v in cls]
+
+    test: TestType
     """The way that the check value will be compared to the actual count
     """
 
@@ -109,7 +108,7 @@ def from_dict(d: dict):
         with_attribute = None
         if d["with_attribute"] is not None:
             with_attribute = Attribute.from_dict(d["with_attribute"])
-        test = CountConditionTestType(d["test"])
+        test = ZoneAlarmCountCondition.TestType(d["test"])
 
         return ZoneAlarmCountCondition(
             test=test,
@@ -122,42 +121,40 @@ def from_dict(d: dict):
             id=d["id"])
 
 
-class RateConditionTestType(Enum):
-    """Defines the way a rate condition compares the actual rate value to the
-    alarm's test value.
+@dataclass
+class ZoneAlarmRateCondition(Codec):
+    """A condition that must be met for an alarm to go off. Compares the rate
+    of change in the count of some object against a test value.
     """
 
-    GREATER_THAN_OR_EQUAL_TO = ">="
-    LESS_THAN_OR_EQUAL_TO = "<="
+    class TestType(Enum):
+        """Defines the way a rate condition compares the actual rate value to
+        the alarm's test value.
+        """
 
-    @classmethod
-    def values(cls):
-        return [v.value for v in cls]
+        GREATER_THAN_OR_EQUAL_TO = ">="
+        LESS_THAN_OR_EQUAL_TO = "<="
 
+        @classmethod
+        def values(cls):
+            return [v.value for v in cls]
 
-class DirectionType(Enum):
-    """Defines the direction of flow that a rate condition pertains to."""
-
-    ENTERING = "entering"
-    EXITING = "exiting"
-    ENTERING_OR_EXITING = "entering_or_exiting"
-
-    @classmethod
-    def values(cls):
-        return [v.value for v in cls]
+    class DirectionType(Enum):
+        """Defines the direction of flow that a rate condition pertains to."""
 
+        ENTERING = "entering"
+        EXITING = "exiting"
+        ENTERING_OR_EXITING = "entering_or_exiting"
 
-@dataclass
-class ZoneAlarmRateCondition(Codec):
-    """A condition that must be met for an alarm to go off. Compares the rate
-    of change in the count of some object against a test value.
-    """
+        @classmethod
+        def values(cls):
+            return [v.value for v in cls]
 
     _direction_map = {DirectionType.ENTERING: "entered",
                       DirectionType.EXITING: "exited",
                       DirectionType.ENTERING_OR_EXITING: "entered or exited"}
 
-    test: RateConditionTestType
+    test: TestType
     """The way that the change value will be compared to the actual rate"""
 
     duration: float
@@ -210,13 +207,13 @@ def from_dict(d: dict):
         with_attribute = None
         if d["with_attribute"] is not None:
             with_attribute = Attribute.from_dict(d["with_attribute"])
-        test = RateConditionTestType(d["test"])
+        test = ZoneAlarmRateCondition.TestType(d["test"])
 
         return ZoneAlarmRateCondition(
             test=test,
             duration=d["duration"],
             change=d["change"],
-            direction=DirectionType(d["direction"]),
+            direction=ZoneAlarmRateCondition.DirectionType(d["direction"]),
             with_class_name=d["with_class_name"],
             with_attribute=with_attribute,
             intersection_point=intersection_point,

brainframe/api/bf_codecs/config_codecs.py

@@ -6,24 +6,23 @@
 from .base_codecs import Codec
 
 
-class ConnType(Enum):
-    IP_CAMERA = "ip_camera"
-    """A network camera that uses RTSP or HTTP"""
-    WEBCAM = "webcam"
-    """A webcam (usually USB)"""
-    FILE = "file"
-    """An uploaded video file"""
-
-    @classmethod
-    def values(cls):
-        return [v.value for v in cls]
-
-
 @dataclass
 class StreamConfiguration(Codec):
     """Describes a video stream that BrainFrame may connect to and analyze.
     """
 
+    class ConnType(Enum):
+        IP_CAMERA = "ip_camera"
+        """A network camera that uses RTSP or HTTP"""
+        WEBCAM = "webcam"
+        """A webcam (usually USB)"""
+        FILE = "file"
+        """An uploaded video file"""
+
+        @classmethod
+        def values(cls):
+            return [v.value for v in cls]
+
     name: str
     """The human-readable name of the video stream"""
 
@@ -78,7 +77,7 @@ def to_dict(self):
 
     @staticmethod
     def from_dict(d):
-        connection_t = ConnType(d["connection_type"])
+        connection_t = StreamConfiguration.ConnType(d["connection_type"])
         return StreamConfiguration(name=d["name"],
                                    id=d["id"],
                                    connection_type=connection_t,

brainframe/api/bf_codecs/license_codecs.py

@@ -54,22 +54,21 @@ def from_dict(d: dict) -> "LicenseTerms":
         return terms
 
 
-class LicenseState(Enum):
-    VALID = "valid"
-    """A valid license is loaded, features should be enabled"""
-    INVALID = "invalid"
-    """A license was provided, but did not pass validation"""
-    EXPIRED = "expired"
-    """A license was provided, but it has expired"""
-    MISSING = "missing"
-    """No license was provided"""
-
-
 @dataclass
 class LicenseInfo(Codec):
     """Information on the licensing status of the server"""
 
-    state: LicenseState
+    class State(Enum):
+        VALID = "valid"
+        """A valid license is loaded, features should be enabled"""
+        INVALID = "invalid"
+        """A license was provided, but did not pass validation"""
+        EXPIRED = "expired"
+        """A license was provided, but it has expired"""
+        MISSING = "missing"
+        """No license was provided"""
+
+    state: State
     """The licensing state of the server."""
 
     terms: Optional[LicenseTerms]
@@ -90,7 +89,7 @@ def from_dict(d: dict) -> "LicenseInfo":
             terms = LicenseTerms.from_dict(d["terms"])
 
         return LicenseInfo(
-            state=LicenseState(d["state"]),
+            state=LicenseInfo.State(d["state"]),
             terms=terms,
         )