Added optional validation to attributes that are considered mandatory in the spec.

Author: avishaycohen

.gitignore

@@ -136,4 +136,5 @@ dmypy.json
 
 # Windows python venv
 /Scripts/
-pyvenv.cfg
+pyvenv.cfg
+/share/

src/mpd_parser/exceptions.py

@@ -18,3 +18,7 @@ class UnknownElementTreeParseError(Exception):
 class NoPeriodAncestorForTargetElement(Exception):
     """ Raised when trying to create a timeline from template without parent period """
     description = "targeted segment template is not nested under a periods"
+
+class InvalidManifestMissingMandatoryElementError(Exception):
+    """ Raised when the manifest is missing a mandatory element """
+    description = "manifest is missing a mandatory element, check the MPD specification for more information"

src/mpd_parser/models/base_tags.py

@@ -46,6 +46,22 @@ def __setattr__(self, key: str, value: Any) -> None:
 
         self.element.attrib[element_attrib_name] = str(value)
 
+    def validate(self) -> None:
+        """
+        Validate the tag, should be implemented by subclasses when adding @mandatory attributes,
+        overload this method and use super to call it after validating specific elements.
+        """
+        for attr_name in dir(self):
+            # Skip private/protected and methods
+            if attr_name.startswith("_"):
+                continue
+            attr = getattr(self, attr_name)
+            # Check if it's a list of Tag instances
+            if isinstance(attr, list) and attr and isinstance(attr[0], Tag):
+                for child in attr:
+                    child.validate()
+
+
     @classmethod
     def to_camel_case(cls, snake_case_string: str) -> str:
         """convert snake_case to lowerCamelCase"""

src/mpd_parser/models/composite_tags.py

@@ -34,6 +34,7 @@
 )
 from mpd_parser.models.segment_tags import MultipleSegmentBase, SegmentBase, SegmentList
 from mpd_parser.timeline_utils import SegmentTiming
+from mpd_parser.validation import mandatory
 
 
 class Period(Tag):
@@ -156,6 +157,15 @@ def __init__(self, element: Element, encoding: str = "utf-8"):
         self.encoding = encoding
         self.tag_map = {"cenc": "xlmns:cenc"}
 
+    def validate(self):
+        """Validate the MPD object against the DASH specification.
+        This starts a recursive validation of all the tags and their children.
+        Raises:
+            InvalidManifestMissingMandatoryElementError: if a mandatory element is missing
+        """
+        _ = self.min_buffer_time
+        super().validate()
+
     @cached_property
     def namespace(self):
         value = self.element.nsmap
@@ -234,10 +244,19 @@ def minimum_update_period_in_seconds(self):
             else TWO_SECONDS  # default for minimumUpdatePeriod
         )
 
-    @cached_property
+    @mandatory
     def min_buffer_time(self):
         return self.element.attrib.get("minBufferTime")
 
+    @property
+    @lru_cache
+    def min_buffer_time_in_seconds(self) -> float:
+        return (
+            parse_duration(self.min_buffer_time).total_seconds()
+            if self.min_buffer_time
+            else ZERO_SECONDS
+        )
+
     @cached_property
     def time_shift_buffer_depth(self):
         return self.element.attrib.get("timeShiftBufferDepth")
@@ -551,11 +570,17 @@ def content_component(self):
 class Representation(RepresentationBase):
     """Representation tag"""
 
-    @cached_property
+    def validate(self):
+        """ Check mandatory attributes have values. """
+        _ = self.id
+        _ = self.bandwidth
+        super().validate()
+
+    @mandatory
     def id(self):
         return self.element.attrib.get("id")
 
-    @cached_property
+    @mandatory
     def bandwidth(self):
         return get_int_value(self.element.attrib.get("bandwidth"))
 

src/mpd_parser/parser.py

@@ -28,7 +28,7 @@ class Parser:
     """
 
     @classmethod
-    def from_string(cls, manifest_as_string: str) -> MPD:
+    def from_string(cls, manifest_as_string: str, validate: bool = False) -> MPD:
         """generate a parsed mpd object from a given string
 
         Args:
@@ -57,12 +57,15 @@ def cut_and_burn(match: Match) -> str:
         except Exception as err:
             logger.exception("Failed to parse manifest string")
             raise UnknownElementTreeParseError() from err
-        if encoding:
-            return MPD(root, encoding=encoding[0].groups()[0])
-        return MPD(root)
+
+        mpd = MPD(root, encoding=encoding[0].groups()[0] if encoding else "utf-8")
+
+        if validate:
+            mpd.validate()
+        return mpd
 
     @classmethod
-    def from_file(cls, manifest_file_name: str) -> MPD:
+    def from_file(cls, manifest_file_name: str, validate: bool = False) -> MPD:
         """
             Generate a parsed mpd object from a given file name
         Args:
@@ -81,10 +84,14 @@ def from_file(cls, manifest_file_name: str) -> MPD:
         except Exception as err:
             logger.exception("Failed to parse manifest file %s", manifest_file_name)
             raise UnknownElementTreeParseError() from err
-        return MPD(tree.getroot())
+
+        mpd = MPD(tree.getroot())
+        if validate:
+            mpd.validate()
+        return mpd
 
     @classmethod
-    def from_url(cls, url: str) -> MPD:
+    def from_url(cls, url: str, validate: bool = False) -> MPD:
         """
             Generate a parsed mpd object from a given URL
         Args:
@@ -104,7 +111,11 @@ def from_url(cls, url: str) -> MPD:
         except Exception as err:
             logger.exception("Failed to parse manifest from URL %s", url)
             raise UnknownElementTreeParseError() from err
-        return MPD(tree.getroot())
+
+        mpd = MPD(tree.getroot())
+        if validate:
+            mpd.validate()
+        return mpd
 
     @classmethod
     def to_string(cls, mpd: MPD) -> str:

src/mpd_parser/validation.py

@@ -0,0 +1,16 @@
+"""
+This module provides validation tools for tags and attributes.
+"""
+from functools import cached_property
+from mpd_parser.exceptions import InvalidManifestMissingMandatoryElementError
+
+def mandatory(func):
+    """ Decorator to mark a method as mandatory. """
+    @cached_property
+    def wrapper(self, *args, **kwargs):
+        value = func(self, *args, **kwargs)
+        if value is None:
+            raise InvalidManifestMissingMandatoryElementError(
+                f"Mandatory attribute '{func.__name__}' is missing in {type(self).__name__}")
+        return value
+    return wrapper