Alias for |expand_repertoire()| with ``direction`` set to |EFFECT|.
165669
def expand_effect_repertoire(self, repertoire, new_purview=None):
        
        return self.expand_repertoire(Direction.EFFECT, repertoire,
                                      new_purview)
489702
def chorus(self, gain_in, gain_out, decays):
        """"""
        self.command.append("chorus")
        self.command.append(gain_in)
        self.command.append(gain_out)
        for decay in decays:
            modulation = decay.pop()
            numerical = decay
            self.command.append(' '.join(map(str, numerical)) + ' -' + modulation)
        return self
1119623
def expand_curlys(s):
    
    from functools import reduce
    curleys = list(re.finditer(r"{[^{}]*}", s))
    return reduce(_replace_curly, reversed(curleys), [s])
448345
def load_repertoire(name):
    """"""
    root = os.path.abspath(os.path.dirname(__file__))
    filename = os.path.join(root, 'data', 'emd', name)

    return np.load(filename)
691897
def expand(sequence):
    
    expanse = []
    for point in sequence:
        if 'sequence' in point:
            expanse.extend(expand(point['sequence']))
        else:
            expanse.append(point)
    return sequence.__class__(expanse)
616220
function expand(to, from) {

   const keys = Object.keys(from)
   for (const key of keys) {
      if (!to.hasOwnProperty(key))
         to[key] = from[key]
   }

}
1211983
def expand_all(self):
        """"""
        block = self.editor.document().firstBlock()
        while block.isValid():
            TextBlockHelper.set_collapsed(block, False)
            block.setVisible(True)
            block = block.next()
        self._clear_block_deco()
        self._refresh_editor_and_scrollbars()
        self.expand_all_triggered.emit()
529613
def _expand_dims(x, input_shape, output_shape):
  
  verify_no_new_dims([output_shape], input_shape)
  if input_shape == output_shape or input_shape.ndims == 0:
    return x
  perm = [input_shape.dims.index(d) for d in output_shape.dims
          if d in input_shape.dims]
  x = tf.transpose(x, perm)
  for i, d in enumerate(output_shape.dims):
    if d not in input_shape.dims:
      x = tf.expand_dims(x, i)
  return x
1268351
function expandToWord(sel) {
	sel = sel || getSelection();
	if (sel.modify) {
		collapseStart(sel);
		sel.modify('move', 'backward', 'word');
		sel.modify('extend', 'forward', 'word');
	} else if (sel.type !== 'Control') {
		var range = sel.createRange();
		range.collapse(true);
		range.expand('word');
	}
}
1198187
def _expand_inputs(step, steps=None):
    
    if steps is None:
        steps = set()

    for arg in step._kwargs.values():
        if isinstance(arg, Step):
            _expand_inputs(arg, steps=steps)
        elif util.is_instance_collection(arg, Step):
            for s in util.get_collection_values(arg):
                _expand_inputs(s, steps=steps)

    steps.add(step)
    return steps
46396
def expand_item(self, item, open_all=True):
        
        self.expand_row(self._view_path_for(item), open_all)
121596
def _abbrieviate_direction(ext_dir_str):
    """"""
    return (ext_dir_str
            .upper()
            .replace('_', '')
            .replace('-', '')
            .replace(' ', '')
            .replace('NORTH', 'N')
            .replace('EAST', 'E')
            .replace('SOUTH', 'S')
            .replace('WEST', 'W')
            )
1306049
def _expand(self, line: str) -> str:
        """"""

        # expand aliases
        # make a copy of aliases so we can edit it
        tmp_aliases = list(self.aliases.keys())
        keep_expanding = bool(tmp_aliases)
        while keep_expanding:
            for cur_alias in tmp_aliases:
                keep_expanding = False
                # apply our regex to line
                match = self._command_pattern.search(line)
                if match:
                    # we got a match, extract the command
                    command = match.group(1)
                    if command and command == cur_alias:
                        # rebuild line with the expanded alias
                        line = self.aliases[cur_alias] + match.group(2) + line[match.end(2):]
                        tmp_aliases.remove(cur_alias)
                        keep_expanding = bool(tmp_aliases)
                        break

        # expand shortcuts
        for (shortcut, expansion) in self.shortcuts:
            if line.startswith(shortcut):
                # If the next character after the shortcut isn't a space, then insert one
                shortcut_len = len(shortcut)
                if len(line) == shortcut_len or line[shortcut_len] != ' ':
                    expansion += ' '

                # Expand the shortcut
                line = line.replace(shortcut, expansion, 1)
                break
        return line
732084
def _expand_paths_itr(paths, marker='*'):
    
    for path in paths:
        if is_path(path):
            if marker in path:  # glob path pattern
                for ppath in sglob(path):
                    yield ppath
            else:
                yield path  # a simple file path
        elif is_path_obj(path):
            if marker in path.as_posix():
                for ppath in sglob(path.as_posix()):
                    yield normpath(ppath)
            else:
                yield normpath(path.as_posix())
        elif is_ioinfo(path):
            yield path.path
        else:  # A file or file-like object
            yield path
952600
def expand(self, vs=None, conj=False):
        """"""
        vs = self._expect_vars(vs)
        if vs:
            outer, inner = (And, Or) if conj else (Or, And)
            terms = [inner(self.restrict(p),
                           *boolfunc.point2term(p, conj))
                     for p in boolfunc.iter_points(vs)]
            if conj:
                terms = [term for term in terms if term is not One]
            else:
                terms = [term for term in terms if term is not Zero]
            return outer(*terms, simplify=False)
        else:
            return self
127868
def ExtendAnomalies(self, other):
    """"""
    for o in other:
      if o is not None:
        self.anomaly.Extend(list(o.anomaly))
87851
function expand (base, sub) {
    var children = splitSelector(sub)
    return splitSelector(base).reduce(function (selectors, parent) {
      return selectors.concat(children.map(function (child) {
        return parent + ' ' + child
      }))
    }, []).join(', ')
  }