csoundengine 2.22.4__tar.gz → 2.22.6__tar.gz

{csoundengine-2.22.4 → csoundengine-2.22.6}/.github/workflows/test2.yml

@@ -40,8 +40,15 @@ jobs:
           curl -L -o csound-binaries.zip https://github.com/csound/csound/releases/download/6.18.1/Csound-6.18.1-windows-x64-binaries.zip
           Expand-Archive csound-binaries.zip -DestinationPath "csound-binaries"
           ls -r
-          Move-Item -Force -Path ".\csound-binaries\build\Release\*" -Destination "C:\Program Files\csound"
-          ls -r "C:/Program Files/csound"
+          $csoundpath = "C:/Program Files/csound"
+          
+          Move-Item -Force -Path ".\csound-binaries\build\Release\*" -Destination $csoundpath
+          if (-Not (Test-Path $csoundpath)) {
+              Write-Error "The path '$csoundpath' does not exist."
+              exit 1
+          } else {
+              ls -Recurse $csoundpath
+          }
 
           "C:/Program Files/csound" | Out-File -FilePath $env:GITHUB_PATH -Append
           # [Environment]::SetEnvironmentVariable("PATH", $Env:PATH + ";C:/Program Files/csound", [EnvironmentVariableTarget]::Machine)

{csoundengine-2.22.4 → csoundengine-2.22.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csoundengine
-Version: 2.22.4
+Version: 2.22.6
 Summary: An audio synthesis framework using csound
 Author-email: Eduardo Moguillansky <eduardo.moguillansky@gmail.com>
 License: GNU GENERAL PUBLIC LICENSE

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/abstractrenderer.py

@@ -70,7 +70,7 @@ class AbstractRenderer(ABC):
                  includes: list[str] | None = None,
                  aliases: dict[str, str] | None = None,
                  useDynamicPfields: bool | None = None,
-                 initCallback: Callable[[AbstractRenderer], None] = None,
+                 initCallback: Callable[[AbstractRenderer], None] | None = None,
                  **kws) -> _instr.Instr:
         raise NotImplementedError
 
@@ -134,9 +134,9 @@ class AbstractRenderer(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def getInstr(self, instrname: str) -> _instr.Instr | None:
+    def getInstr(self, name: str) -> _instr.Instr | None:
         """
-        Returns the Instr instance corresponding to instrname, or None if no such instr
+        Returns the Instr instance corresponding to name, or None if no such instr
         """
         raise NotImplementedError
 
@@ -221,7 +221,7 @@ class AbstractRenderer(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def _registerTable(self, tabproxy: tableproxy.TableProxy):
+    def _registerTable(self, tabproxy: tableproxy.TableProxy) -> None:
         raise NotImplementedError
 
     @abstractmethod

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/baseschedevent.py

@@ -127,9 +127,9 @@ class BaseSchedEvent(ABC):
                     self._setTable(param=param, value=value, delay=delay)
                 else:
                     raise KeyError(f"Unknown parameter: '{param}'. "
-                                   f"Possible parameters for this event: {self.dynamicParamNames(aliased=True)}, "
-                                   f"aliases: {self.aliases()}, pfields: {self.pfieldNames(aliases=False)}, "
-                                   f"control names: {self.controlNames(aliases=False)}")
+                                   f"Possible parameters for this event: {self.dynamicParamNames()}, "
+                                   f"aliases: {self.aliases()}, pfields: {self.pfieldNames()}, "
+                                   f"control names: {self.controlNames()}")
 
     def _automatePfield(self,
                         param: int | str,
@@ -237,7 +237,7 @@ class BaseSchedEvent(ABC):
         else:
             raise KeyError(f"Unknown parameter '{param}', supported parameters: {self.dynamicParamNames()}")
 
-    def dynamicParamNames(self, aliases=True, aliased=False) -> frozenset[str]:
+    def dynamicParamNames(self, aliases=False) -> frozenset[str]:
         """
         The set of all dynamic parameters accepted by this event
 
@@ -248,8 +248,7 @@ class BaseSchedEvent(ABC):
         dynparams = set(p for p in params if p.startswith('k'))
         if aliases and (_aliases := self.aliases()):
             dynparams |= _aliases.keys()
-            if not aliased:
-                dynparams.difference_update(_aliases.values())
+            dynparams.difference_update(_aliases.values())
         return frozenset(dynparams)
 
     def aliases(self) -> dict[str, str]:
@@ -269,15 +268,13 @@ class BaseSchedEvent(ABC):
         orig = self.aliases().get(param)
         return orig if orig is not None else default
 
-    def pfieldNames(self, aliases=True, aliased=False) -> frozenset[str]:
+    def pfieldNames(self, aliases=False) -> frozenset[str]:
         """
         Returns a set of all named pfields
 
         Args:
-            aliases: if True, included aliases for pfields (if applicable)
-            aliased: if True, include the aliased names. Otherwise if aliases
-                are defined and included (aliases=True), the original names
-                will be excluded
+            aliases: if True, use aliases for pfields (if applicable). An
+                alias shadows the original param
 
         Returns:
             a set with the all pfield names.
@@ -285,13 +282,12 @@ class BaseSchedEvent(ABC):
         """
         raise NotImplementedError
 
-    def controlNames(self, aliases=True, aliased=False) -> frozenset[str]:
+    def controlNames(self, aliases=False) -> frozenset[str]:
         """
         The names of all controls
 
         Args:
             aliases: if True, included control names aliases (if applicable)
-            aliased: if True, include the aliased names
 
         Returns:
             the names of all controls. Returns an empty set if this event
@@ -299,7 +295,7 @@ class BaseSchedEvent(ABC):
         """
         raise NotImplementedError
 
-    def paramNames(self, aliases=True, aliased=False) -> frozenset[str]:
+    def paramNames(self, aliases=False) -> frozenset[str]:
         """
         Set of all named parameters
 
@@ -308,8 +304,8 @@ class BaseSchedEvent(ABC):
             :meth:`~BaseEvent.dynamicParams`, :meth:`~BaseEvent.set`,
             :meth:`~BaseEvent.automate`
         """
-        pargs = self.pfieldNames(aliases=aliases, aliased=aliased)
-        tableargs = self.controlNames(aliases=aliases, aliased=aliased)
+        pargs = self.pfieldNames(aliases=aliases)
+        tableargs = self.controlNames(aliases=aliases)
         if pargs and tableargs:
             return pargs | tableargs
         elif pargs:
@@ -355,7 +351,7 @@ class BaseSchedEvent(ABC):
         instrspecs = self.paramSpecs()
         if instrspecs:
             specdict.update(instrspecs)
-        dynparams = self.dynamicParamNames(aliases=False, aliased=True)
+        dynparams = self.dynamicParamNames(aliases=False)
         for param in dynparams:
             value = self.paramValue(param)
             if spec := specdict.get(param):

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/csd.py

@@ -346,7 +346,7 @@ class Csd:
 
         self._outfileFormat = ''
         self._outfileEncoding = ''
-        self._compressionQuality = ''
+        self._compressionQuality = 0.
 
         self._definedTables: Set[int] = set()
         self._minTableIndex = 1
@@ -568,8 +568,8 @@ class Csd:
         sizeThreshold = config['offline_score_table_size_limit']
 
         if isinstance(data, np.ndarray) and sr:
-            sndfile = _tempfile.mktemp(suffix=".wav")
             import sndfileio
+            sndfile = _tempfile.mktemp(suffix=".wav")
             sndfileio.sndwrite(sndfile, samples=data, sr=sr, encoding='float32')
             tabnum = self.addSndfile(sndfile, tabnum=tabnum, asProjectFile=True,
                                      start=start)

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/csoundlib.py

@@ -23,6 +23,7 @@ import shutil as _shutil
 import subprocess as _subprocess
 import tempfile as _tempfile
 import textwrap as _textwrap
+import struct
 
 import cachetools as _cachetools
 import numpy as np
@@ -331,7 +332,6 @@ class _PortaudioBackend(AudioBackend):
             return info.sr if info is not None else 44100
         return super().getSystemSr()
 
-    @_functools.cache
     def defaultAudioDevices(self) -> tuple[AudioDevice | None, AudioDevice | None]:
         logger.debug("Querying default device via portaudio/sounddevice")
         try:
@@ -1251,18 +1251,6 @@ def getAudioBackendNames() -> list[str]:
     return [b.name for b in audioBackends()]
 
 
-# @_functools.cache
-# def _instrReplacer() -> Callable[[str], str]:
-#     return emlib.textlib.makeReplacer({".":"_", ":":"_", " ":"_"})
-
-
-# def normalizeInstrumentName(name: str) -> str:
-#     """
-#     Transform name so that it can be accepted as an instrument name
-#     """
-#     return _instrReplacer()(name)
-
-
 def mincer(sndfile: str,
            outfile: str,
            timecurve: float | Callable[[float], float] = 1.,
@@ -1489,6 +1477,77 @@ def recInstr(body: str, events: list, init='', outfile='',
     return outfile, renderjob.process
 
 
+def _ftsaveReadBinary(path: str) -> list[tuple[dict, np.ndarray]]:
+    """
+    Header: sizeof(FUNC) - sizeof(MYFLT) - SSTRSIZ = 152
+
+    where:
+
+    sizeof(FUNC) = 1184
+    MYFLT = double (8 bytes)
+    SSTRSIZ = 1024
+    """
+    # Format string for the 152-byte cropped FUNC struct
+    # Assuming little-endian, 64-bit platform, MYFLT = double
+    FUNC_FORMAT = ('<'
+                   'I'     # flen       uint32_t  4
+                   'i'     # lenmask    int32     4
+                   'i'     # lobits     int32     4
+                   'i'     # lomask     int32     4
+                   'd'     # lodiv      MYFLT     8
+                   'd'     # cvtbas     MYFLT     8
+                   'd'     # cpscvt     MYFLT     8
+                   'hh'    # loopmode1, loopmode2  int16 x2  4
+                   'xxxx'  # padding               4
+                   'iiii'  # begin1, end1, begin2, end2  16
+                   'ii'    # soundend, flenfrms    8
+                   'ii'    # nchanls, fno         8
+                   'd'     # sr        MYFLT      8
+                   'Q'     # *args     pointer    8
+                   'i'     # argcnt    int32_t    4
+                   'xxxx') # padding               4
+
+    # Verify size
+    assert struct.calcsize(FUNC_FORMAT) == 152, \
+        f"Expected 152 bytes, got {struct.calcsize(FUNC_FORMAT)}"
+
+    """Read a cropped FUNC struct (152 bytes) from a binary file."""
+    with open(path, 'rb') as f:
+        header = f.read(152)
+
+        if len(header) < 152:
+            raise ValueError(f"File too short: expected 152 bytes, got {len(data)}")
+
+        fields = struct.unpack(FUNC_FORMAT, header)
+        tablelen = fields[0]
+        data = f.read((tablelen + 1) * 8)
+
+    tabinfo = {
+        'flen':       fields[0],
+        'lenmask':    fields[1],
+        'lobits':     fields[2],
+        'lomask':     fields[3],
+        'lodiv':      fields[4],
+        'cvtbas':     fields[5],
+        'cpscvt':     fields[6],
+        'loopmode1':  fields[7],
+        'loopmode2':  fields[8],
+        'begin1':     fields[9],
+        'end1':       fields[10],
+        'begin2':     fields[11],
+        'end2':       fields[12],
+        'soundend':   fields[13],
+        'flenfrms':   fields[14],
+        'nchanls':    fields[15],
+        'fno':        fields[16],
+        'sr':         fields[17],
+        'args':       fields[18],  # raw pointer value (not dereferenceable)
+        'argcnt':     fields[19],
+    }
+    arr = np.frombuffer(data, dtype=np.float64)
+    return [(tabinfo, arr)]
+
+
 def _ftsaveReadText(path: str) -> list[np.ndarray]:
     # a file can have multiple tables saved
     lines = iter(open(path))
@@ -1510,7 +1569,7 @@ def _ftsaveReadText(path: str) -> list[np.ndarray]:
                 break
         if tablength < 0:
             raise IOError("Could not read table length")
-        values = np.zeros((tablength+1,), dtype=float)
+        values  = np.zeros((tablength+1,), dtype=float)
         # Read data
         for i, line in enumerate(lines):
             if line.startswith("---"):
@@ -1520,12 +1579,28 @@ def _ftsaveReadText(path: str) -> list[np.ndarray]:
     return tables
 
 
-def ftsaveRead(path, mode="text") -> list[np.ndarray]:
+def ftsaveRead(path: str, mode="") -> list[tuple[dict, np.ndarray]]:
     """
     Read a file saved by ftsave, returns a list of tables
-    """
+
+    Args:
+        path: the path to the saved table/tables
+        mode: one of "text", "binary" or empty to auto-detect the format
+
+    Returns:
+        a list of (tableinfo: dict, tabledata: np.ndarray), where
+        tableinfo is a dict containing information about the table. This
+        dict is only populated if the table was saved in binary format,
+        for text tables this dict will be empty
+    """
+    if not mode:
+        from . import tools
+        mode = "binary" if tools.isFileBinary(path) else "text"
     if mode == "text":
-        return _ftsaveReadText(path)
+        arrays = _ftsaveReadText(path)
+        return [({}, arr) for arr in arrays]
+    elif mode == "binary" or mode == "bin":
+        return _ftsaveReadBinary(path)
     else:
         raise ValueError(f"mode {mode} not supported")
 
@@ -1671,29 +1746,6 @@ def dumpAudioDevices(backend=''):
         print("-- No output devices")
 
 
-# def _hashdict(d: dict) -> int:
-#     return hash((frozenset(d.keys()), frozenset(d.values())))
-
-
-# def _parsePresetSflistprograms(line: str) -> tuple[str, int, int] | None:
-#     # 012345678
-#     # xxx:yyy zzzzzzzzzz
-#     bank = int(line[:3])
-#     num = int(line[4:7])
-#     name = line[8:].strip()
-#     return (name, bank, num)
-
-
-# def _parsePreset(line: str) -> tuple[str, int, int] | None:
-#     match = _re.search(r">> Bank: (\d+)\s+Preset:\s+(\d+)\s+Name:\s*(.+)", line)
-#     if not match:
-#         return None
-#     name = match.group(3).strip()
-#     bank = int(match.group(1))
-#     presetnum = int(match.group(2))
-#     return (name, bank, presetnum)
-
-
 def channelTypeFromValue(value: int | float | str | np.ndarray) -> str:
     """
     Channel type (k, S, a) from value

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/engine.py

@@ -2053,6 +2053,7 @@ class Engine(_EngineBase):
                   callback=None,
                   ) -> int:
         """
+
         Create a new table and fill it with data.
 
         Args:

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/enginebase.py

@@ -158,7 +158,7 @@ class _EngineBase(ABC):
         ...
 
     @abstractmethod
-    def setChannel(self, channel: str, value: float | str | np.ndarray, delay=0.): ...
+    def setChannel(self, channel: str, value: float | str | np.ndarray, delay=0., method=''): ...
 
     @abstractmethod
     def channelPointer(self, channel: str, kind='control', mode='rw') -> np.ndarray:

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/engineorc.py

@@ -18,7 +18,7 @@ gi__responses       ftgen  ${responses}, 0, ${numTokens}, -2, 0
 gi__tokenToInstrnum ftgen ${tokenToInstrnum}, 0, ${maxNumInstrs}, -2, 0
 gi__soundfontIndexes dict_new "str:float"
 gi__soundfontIndexCounter init 1000
-gi__builtinInstrs dict_new "str:float", "notifyDealloc", ${notifyDealloc}
+gi__builtinInstrs dict_new "str:float", "notifyDealloc", ${notifyDealloc}, "notifyDeallocOSC", ${notifyDeallocOSC}
 
 chn_k "_soundfontPresetCount", 3
 
@@ -87,11 +87,12 @@ opcode sendsync, 0, ii
 endop
 
 instr ${notifyDealloc}
+    iunused = p5
     outvalue "__dealloc__", p4
     turnoff
 endin
 
-instr ${notifyDeallocOsc}
+instr ${notifyDeallocOSC}
     ; p4=p1, p5=port
     OSCsend 1, "127.0.0.1", p5, "/dealloc", "d", p4
     turnoff

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/instr.py

@@ -586,7 +586,7 @@ class Instr:
         return orig if orig is not None else default
 
     @cache
-    def controlNames(self, aliases=True, aliased=False) -> frozenset[str]:
+    def controlNames(self, aliases=False) -> frozenset[str]:
         """
         Set of names of the controls in this instr
 
@@ -599,12 +599,11 @@ class Instr:
             for name in self.controls.keys():
                 if alias := self._argToAlias.get(name):
                     names.add(alias)
-                    if not aliased:
-                        names.remove(name)
+                    names.remove(name)
         return frozenset(names)
 
     @cache
-    def dynamicParamNames(self, aliases=True, aliased=False
+    def dynamicParamNames(self, aliases=False
                           ) -> frozenset[str]:
         """
         Set of all dynamic parameters accepted by this Instr
@@ -616,11 +615,11 @@ class Instr:
         Returns:
             a set of the dynamic (modifiable) parameters accepted by this Instr
         """
-        dynparams = self.dynamicParams(aliases=aliases, aliased=aliased)
+        dynparams = self.dynamicParams(aliases=aliases)
         return frozenset(dynparams.keys())
 
     @cache
-    def dynamicPfields(self, aliases=True, aliased=False) -> dict[str, float]:
+    def dynamicPfields(self, aliases=False) -> dict[str, float]:
         """
         The dynamic pfields in this instr
 
@@ -644,8 +643,7 @@ class Instr:
             for alias, realname in self.aliases.items():
                 if realname in pfields:
                     pfields[alias] = pfields[realname]
-                    if not aliased:
-                        pfields.pop(realname, None)
+                    pfields.pop(realname, None)
 
         # We know that pfields cannot hold any string since we are selecting by 'k' prefix
         return pfields   # type: ignore
@@ -680,7 +678,7 @@ class Instr:
         return frozenset(pfields)
 
     @cache
-    def dynamicParams(self, aliases=True, aliased=False
+    def dynamicParams(self, aliases=False
                       ) -> dict[str, float]:
         """
         A dict with all dynamic parameters defined in this instr
@@ -708,20 +706,18 @@ class Instr:
             params = params.copy()
             for alias, realname in self.aliases.items():
                 params[alias] = params[realname]
-                if not aliased:
-                    del params[realname]
+                del params[realname]
         return params
 
-    def paramNames(self, aliases=True, aliased=False
+    def paramNames(self, aliases=False
                    ) -> frozenset[str]:
         """
         All parameter names
         """
-        pfields = self.pfieldNames(aliases=aliases, aliased=aliased)
+        pfields = self.pfieldNames(aliases=aliases)
         return frozenset(pfields | self.controlNames()) if self.controls else pfields
 
-    # @cache
-    def pfieldNames(self, aliases=True, aliased=False
+    def pfieldNames(self, aliases=False
                     ) -> frozenset[str]:
         """
         The set of named pfields declared in this instrument
@@ -740,8 +736,7 @@ class Instr:
             for alias, realname in self.aliases.items():
                 if realname in pfields:
                     pfields.add(alias)
-                    if not aliased:
-                        pfields.remove(realname)
+                    pfields.remove(realname)
         return frozenset(pfields)
 
     def paramValue(self, param: str) -> float | str | None:
@@ -753,7 +748,7 @@ class Instr:
         return defaults[param2]
 
     @cache
-    def paramDefaultValues(self, aliases=True, aliased=False) -> dict[str, float]:
+    def paramDefaultValues(self, aliases=False) -> dict[str, float]:
         """
         A dict mapping named parameters to their default values
 
@@ -793,8 +788,7 @@ class Instr:
         if self.aliases and aliases:
             for alias, realname in self.aliases.items():
                 params[alias] = params[realname]
-                if not aliased:
-                    del params[realname]
+                del params[realname]
 
         return params
 
@@ -811,8 +805,8 @@ class Instr:
             parameter to its given value
         """
         return instrtools.distributeParams(params=params,
-                                           pfieldNames=self.pfieldNames(aliases=True, aliased=True),
-                                           controlNames=self.controlNames(aliases=True, aliased=True))
+                                           pfieldNames=self.pfieldNames(),
+                                           controlNames=self.controlNames())
 
     def pfieldName(self, index: int, alias=True) -> str:
         """

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/internal.py

@@ -21,7 +21,7 @@ if TYPE_CHECKING:
     import numpy.typing as npt
     from matplotlib.figure import Figure
 
-    from csoundlib import AudioDevice, MidiDevice
+    from csoundengine.csoundlib import AudioDevice, MidiDevice
 
     from .instr import Instr
     T = TypeVar('T')

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/offline.py

@@ -517,7 +517,7 @@ class OfflineSession(AbstractRenderer):
         """
         return self.instrs
 
-    def getInstr(self, name) -> Instr | None:
+    def getInstr(self, name: str) -> Instr | None:
         """
         Find a registered Instr, by name
 

{csoundengine-2.22.4 → csoundengine-2.22.6}/csoundengine/schedevent.py

@@ -224,24 +224,21 @@ class SchedEvent(BaseSchedEvent):
         self._instr = instr
         return instr
 
-    def paramNames(self, aliases=True, aliased=False) -> frozenset[str]:
-        return self.instr.paramNames(aliases=aliases, aliased=aliased)
+    def paramNames(self, aliases=False) -> frozenset[str]:
+        return self.instr.paramNames(aliases=aliases)
 
-    def dynamicParamNames(self, aliases=True, aliased=False) -> frozenset[str]:
+    def dynamicParamNames(self, aliases=False) -> frozenset[str]:
         """
         The set of all dynamic parameters accepted by this Synth
 
         Args:
             aliases: if True, include aliases
-            aliased: include the original names of parameters which have an alias. If both
-                aliases and aliased params are included, there are two names to access
-                the same parameter
 
         Returns:
             a set of the dynamic (modifiable) parameters accepted by this synth
         """
         instr = self.instr
-        return instr.dynamicParamNames(aliases=aliases, aliased=aliased) if instr else EMPTYSET
+        return instr.dynamicParamNames(aliases=aliases) if instr else EMPTYSET
 
     def automate(self,
                  param: str,
@@ -252,8 +249,8 @@ class SchedEvent(BaseSchedEvent):
                  ) -> float:
         param = self.unaliasParam(param, param)
         if self.parent is None:
-            if param not in (params := self.instr.dynamicParams(aliased=True)):
-                raise KeyError(f"Unknown parameter '{param}' for {self}. Possible parameters: {params}")
+            if param not in self.instr.aliases and param not in self.instr.paramNames():
+                raise KeyError(f"Unknown parameter '{param}' for {self}. Possible parameters: {self.instr.paramNames()}")
             if isinstance(pairs, tuple) and len(pairs) == 2 and isinstance(pairs[0], np.ndarray):
                 ts, values = pairs
                 assert isinstance(values, np.ndarray) and isinstance(ts, np.ndarray)
@@ -286,11 +283,15 @@ class SchedEvent(BaseSchedEvent):
         else:
             self.parent.unsched(self, delay=delay)
 
-    def controlNames(self, aliases=True, aliased=False) -> frozenset[str]:
-        return self.instr.controlNames(aliases=aliases, aliased=aliased)
+    def controlNames(self, aliases=False) -> frozenset[str]:
+        return self.instr.controlNames(aliases=aliases)
+
+    def isPfield(self, param: str) -> bool:
+        pfields = self.instr.pfieldNames()
+        return param in pfields and (param2 := self.aliases().get(param)) is not None and param2 in pfiels
 
-    def pfieldNames(self, aliases=True, aliased=False) -> frozenset[str]:
-        return self.instr.pfieldNames(aliases=aliases, aliased=aliased)
+    def pfieldNames(self, aliases=False) -> frozenset[str]:
+        return self.instr.pfieldNames(aliases=aliases)
 
     def paramValue(self, param: str) -> float | str | None:
         param = self.unaliasParam(param, param)
@@ -343,7 +344,7 @@ class SchedEventGroup(BaseSchedEvent):
     def _setPfield(self, param: str, value: float, delay=0.) -> None:
         count = 0
         for ev in self:
-            if param in ev.pfieldNames(aliased=True):
+            if param in ev.pfieldNames(aliases=True):
                 ev._setPfield(delay=delay, param=param, value=value)
                 count += 1
         if count == 0:
@@ -363,7 +364,7 @@ class SchedEventGroup(BaseSchedEvent):
     def paramNames(self, aliases=True, aliased=False) -> frozenset[str]:
         allparams = set()
         for ev in self:
-            allparams.update(ev.paramNames(aliases=aliases, aliased=aliased))
+            allparams.update(ev.paramNames(aliases=aliases))
         return frozenset(allparams)
 
     def paramValue(self, param: str) -> float | str | None:
@@ -383,10 +384,10 @@ class SchedEventGroup(BaseSchedEvent):
         return None
 
     @cache
-    def dynamicParamNames(self, aliases=True, aliased=False) -> frozenset[str]:
+    def dynamicParamNames(self, aliases=False) -> frozenset[str]:
         params = set()
         for ev in self:
-            params.update(ev.dynamicParamNames(aliases=aliases, aliased=aliased))
+            params.update(ev.dynamicParamNames(aliases=aliases))
         return frozenset(params)
 
     def __hash__(self):
@@ -413,7 +414,7 @@ class SchedEventGroup(BaseSchedEvent):
             count = 0
             allparams = set()
             for ev in self:
-                evparams = ev.dynamicParamNames(aliases=True, aliased=True)
+                evparams = ev.dynamicParamNames(aliases=True)
                 allparams.update(evparams)
                 if param in evparams:
                     count += 1
@@ -437,7 +438,7 @@ class SchedEventGroup(BaseSchedEvent):
                  ) -> float:
         count = 0
         for ev in self:
-            if param in ev.dynamicParamNames(aliases=True, aliased=True):
+            if param in ev.dynamicParamNames(aliases=True):
                 count += 1
                 ev.automate(param=param, pairs=pairs, mode=mode,
                             delay=delay, overtake=overtake)