Replace asserts with other exceptions (#465)

Author: josephine-wolf-oberholtzer

supriya/contexts/allocators.py

@@ -82,7 +82,8 @@ def __setstate__(self, state):
 
     def allocate(self, desired_block_size: int = 1) -> Optional[int]:
         desired_block_size = int(desired_block_size)
-        assert 0 < desired_block_size
+        if desired_block_size <= 0:
+            raise ValueError("desired_block_size must be greater than zero")
         block_id = None
         with self._lock:
             free_block = None
@@ -125,7 +126,8 @@ def allocate_at(self, index: int, desired_block_size: int = 1) -> Optional[int]:
             if starting_blocks == stop_blocks:
                 if len(starting_blocks) == 0:
                     return None
-                assert len(starting_blocks) == 1
+                if len(starting_blocks) != 1:
+                    raise RuntimeError
                 free_block = starting_blocks[0]
                 used_block = Block(
                     start_offset=start_offset, stop_offset=stop_offset, used=True
@@ -149,20 +151,23 @@ def free(self, block_id: int) -> None:
             )
             if len(blocks) == 0:
                 return None
-            assert len(blocks) == 1
+            if len(blocks) != 1:
+                raise RuntimeError
             used_block = blocks[0]
             self._used_heap.remove(used_block)
             start_offset = used_block.start_offset
             stopping_blocks = self._free_heap.find_intervals_stopping_at(start_offset)
             if stopping_blocks:
-                assert len(stopping_blocks) == 1
+                if len(stopping_blocks) != 1:
+                    raise RuntimeError
                 stopping_block = stopping_blocks[0]
                 self._free_heap.remove(stopping_block)
                 start_offset = stopping_block.start_offset
             stop_offset = used_block.stop_offset
             starting_blocks = self._free_heap.find_intervals_starting_at(stop_offset)
             if starting_blocks:
-                assert len(starting_blocks) == 1
+                if len(starting_blocks) != 1:
+                    raise RuntimeError
                 starting_block = starting_blocks[0]
                 self._free_heap.remove(starting_block)
                 stop_offset = starting_block.stop_offset

supriya/contexts/nonrealtime.py

@@ -191,7 +191,6 @@ async def render(
             protocol = AsyncNonrealtimeProcessProtocol()
             await protocol.run(command, render_directory_path_)
             exit_code: int = await protocol.exit_future
-            assert render_directory_path_ / render_file_name
             if output_file_path_:
                 shutil.copy(
                     render_directory_path_ / render_file_name, output_file_path_

supriya/ext/mypy.py

@@ -55,10 +55,6 @@ def transform(self) -> bool:
             "supriya.ugens.core.UGenVectorInput"
         )
 
-        assert UGenRecursiveInputTypeSym.node is not None
-        assert UGenScalarInputTypeSym.node is not None
-        assert UGenVectorInputTypeSym.node is not None
-
         UGenRecursiveInputType = getattr(UGenRecursiveInputTypeSym.node, "target")
         UGenScalarInputType = getattr(UGenScalarInputTypeSym.node, "target")
         UGenVectorInputType = getattr(UGenVectorInputTypeSym.node, "target")

supriya/ugens/core.py

@@ -4882,8 +4882,13 @@ def __init__(
         special_index: SupportsInt = 0,
         **kwargs: Union["UGenScalarInput", "UGenVectorInput"],
     ) -> None:
-        if self._valid_calculation_rates:
-            assert calculation_rate in self._valid_calculation_rates
+        if (
+            self._valid_calculation_rates
+            and calculation_rate not in self._valid_calculation_rates
+        ):
+            raise ValueError(
+                f"{calculation_rate} not in {self._valid_calculation_rates}"
+            )
         calculation_rate, kwargs = self._postprocess_kwargs(
             calculation_rate=calculation_rate, **kwargs
         )
@@ -5618,7 +5623,8 @@ def __str__(self) -> str:
             inputs: Dict[str, str] = {}
             if isinstance(ugen, Control):
                 for parameter in ugen.parameters:
-                    assert parameter.name is not None
+                    if parameter.name is None:
+                        raise ValueError(parameter)
                     if len(parameter.value) == 1:
                         inputs[parameter.name] = str(parameter.value[0])
                     else:
@@ -5664,7 +5670,8 @@ def _collect_indexed_parameters(
         for control in controls:
             index = control.special_index
             for parameter in control.parameters:
-                assert parameter.name is not None
+                if parameter.name is None:
+                    raise ValueError(parameter)
                 mapping[parameter.name] = (parameter, index)
                 index += len(parameter)
         return mapping

supriya/ugens/envelopes.py

@@ -34,8 +34,10 @@ def __init__(
         loop_node: Optional[int] = None,
         offset: Union[UGenOperable, float] = 0.0,
     ) -> None:
-        assert len(amplitudes) > 1
-        assert len(durations) == (len(amplitudes) - 1)
+        if len(amplitudes) <= 1:
+            raise ValueError(amplitudes)
+        if not (len(durations) == (len(amplitudes) - 1)):
+            raise ValueError(durations, amplitudes)
         if isinstance(curves, (int, float, str, EnvelopeShape, UGenOperable)):
             curves = [curves]
         elif curves is None:

supriya/ugens/factories.py

@@ -230,7 +230,8 @@ class SynthDefFactory:
 
     def __init__(self, channel_count=1, **kwargs):
         channel_count = int(channel_count)
-        assert channel_count > 0
+        if channel_count <= 0:
+            raise ValueError(channel_count)
         self._channel_count = channel_count
         self._feedback_loop = None
         self._gate = {}
@@ -556,7 +557,8 @@ def with_channel_count(self, channel_count):
                             source[2]: AllpassC.ar/5[0]
         """
         channel_count = int(channel_count)
-        assert channel_count > 0
+        if channel_count <= 0:
+            raise ValueError(channel_count)
         clone = self._clone()
         clone._channel_count = channel_count
         return clone
@@ -1585,7 +1587,8 @@ def with_output(
                             crossfade: BinaryOpUGen(MULTIPLICATION).kr[0]
                             source[0]: AllpassC.ar/1[0]
         """
-        assert not (replacing and crossfaded)
+        if replacing and crossfaded:
+            raise ValueError(replacing, crossfaded)
         clone = self._clone()
         clone._output.update(
             crossfaded=bool(crossfaded),

supriya/ugens/lines.py

@@ -205,7 +205,6 @@ def ar(cls, channel_count=1):
         from . import DC
 
         channel_count = int(channel_count)
-        assert 0 <= channel_count
         silence = DC.ar(source=0)
         if channel_count == 1:
             return silence

supriya/ugens/pv.py

@@ -21,8 +21,10 @@ def fft_size(self) -> UGenOperable:
         Returns ugen input.
         """
         input_ = self.inputs[0]
-        assert isinstance(input_, OutputProxy)
-        assert isinstance(input_.ugen, PV_ChainUGen)
+        if not isinstance(input_, OutputProxy):
+            raise ValueError(input_)
+        if not isinstance(input_.ugen, PV_ChainUGen):
+            raise ValueError(input_.ugen)
         return input_.ugen.fft_size
 
 

supriya/utils/_intervals.pyx

@@ -644,7 +644,8 @@ cdef class IntervalTreeDriverEx:
 
     def find_intervals_intersecting_interval(self, interval):
         cinterval = _CInterval.from_interval(interval)
-        assert isinstance(cinterval, _CInterval)
+        if not isinstance(cinterval, _CInterval):
+            raise ValueError(cinterval)
         cintervals = self._recurse_find_intervals_intersecting_interval(
             self._root_node, cinterval)
         return self._unbox_cintervals(cintervals)
@@ -671,7 +672,8 @@ cdef class IntervalTreeDriverEx:
         return node.start_offset
 
     def index(self, interval):
-        assert self._is_interval(interval)
+        if not self._is_interval(interval):
+            raise ValueError(interval)
         cinterval = _CInterval.from_interval(interval)
         node = self._search(self._root_node, cinterval.start_offset)
         if node is None:

supriya/utils/intervals.py

@@ -1300,7 +1300,8 @@ def iterate_moments_nwise(self, n=3, reverse=False):
         Returns generator.
         """
         n = int(n)
-        assert 0 < n
+        if n < 1:
+            raise ValueError(n)
         if reverse:
             for moment in self.iterate_moments(reverse=True):
                 moments = [moment]
@@ -1432,7 +1433,8 @@ def __init__(self, start_offset, stop_offset, original_interval):
         self.original_interval = original_interval
 
     def __eq__(self, cinterval):
-        assert isinstance(cinterval, type(self)), cinterval
+        if not isinstance(cinterval, type(self)):
+            raise ValueError(cinterval)
         if self.start_offset != cinterval.start_offset:
             return False
         if self.stop_offset != cinterval.stop_offset:
@@ -1442,11 +1444,13 @@ def __eq__(self, cinterval):
         return True
 
     def __ne__(self, cinterval):
-        assert isinstance(cinterval, type(self)), cinterval
+        if not isinstance(cinterval, type(self)):
+            raise ValueError(cinterval)
         return not self.__eq__(cinterval)
 
     def __lt__(self, cinterval):
-        assert isinstance(cinterval, type(self)), cinterval
+        if not isinstance(cinterval, type(self)):
+            raise ValueError(cinterval)
         if self.start_offset < cinterval.start_offset:
             return True
         if self.start_offset > cinterval.start_offset:
@@ -1730,7 +1734,8 @@ def _recurse_getitem_by_slice(self, node, start, stop):
         return result
 
     def _remove_interval(self, cinterval, old_start_offset=None):
-        assert isinstance(cinterval, _CInterval)
+        if not isinstance(cinterval, _CInterval):
+            raise ValueError(cinterval)
         start_offset = cinterval.start_offset
         if old_start_offset is not None:
             start_offset = old_start_offset
@@ -1887,7 +1892,8 @@ def get_start_offset_before(self, offset):
         return node.start_offset
 
     def index(self, interval):
-        assert self._is_interval(interval)
+        if not self._is_interval(interval):
+            raise ValueError(interval)
         cinterval = _CInterval.from_interval(interval)
         node = self._search(self._root_node, cinterval.start_offset)
         if node is None: