def fmt_field(name, value='', key=None, level=0): hl = False # resolve values if isinstance(value, Script): hl = True value = value.script elif cls.is_secret(name, key): reveal = "reveal with: {}".format( HighlightColor( join('avendesora', 'value', cls.get_name(), cls.combine_field(name, key)))) value = ', '.join(cull([value.get_description(), reveal])) elif isinstance(value, (GeneratedSecret, ObscuredSecret)): v = cls.get_scalar(name, key) value = ', '.join(cull([value.get_description(), str(v)])) else: value = str(value) # format values if '\n' in value: value = indent(dedent(value), get_setting('indent')).strip('\n') sep = '\n' elif value: sep = ' ' else: sep = '' if hl: value = HighlightColor(value) name = str(name).replace('_', ' ') leader = level * get_setting('indent') return indent( LabelColor((name if key is None else str(key)) + ':') + sep + value, leader)
def fail(self, *msg, cmd='<unknown>'): msg = join(*msg) try: msg = msg.decode('ascii', errors='replace') except AttributeError: pass try: if self.notify and not Color.isTTY(): Run( [ "mail", "-s", f"{PROGRAM_NAME} failed on {username}@{hostname}" ] + self.notify.split(), stdin=dedent(f"""\ {PROGRAM_NAME} fails. command: {cmd} config: {self.config_name} source: {username}@{fullhostname}:{', '.join(str(d) for d in self.src_dirs)} destination: {self.repository!s} error message: """) + indent(msg) + "\n", modes="soeW", encoding="ascii", ) except Error: pass try: notifier = self.settings.get("notifier") # don't use self.value as we don't want arguments expanded yet if notifier and not Color.isTTY(): Run(self.notifier.format( cmd=cmd, msg=msg, hostname=hostname, user_name=username, prog_name=PROGRAM_NAME, ), modes="SoeW" # need to use the shell as user will generally quote msg ) except Error: pass except KeyError as e: warn("unknown key.", culprit=(self.settings_file, "notifier", e))
def write_playlist(self, path): try: path.write_text(join(*self.songs)) except OSError as e: raise Error(os_error(e))
def __init__(self, filename, sep=':', use_cache=True, update_cache=True): psf_filepath = to_path(filename) cache_filepath = psf_filepath.with_suffix(psf_filepath.suffix + '.cache') # read cache if desired and current if use_cache: try: if cache_filepath.stat().st_mtime > psf_filepath.stat( ).st_mtime: self._read_cache(cache_filepath) return except OSError as e: log(os_error(e)) except Exception as e: log(e) # open and parse PSF file parser = ParsePSF() try: content = psf_filepath.read_text() sections = parser.parse(filename, content) except ParseError as e: raise Error(str(e)) except OSError as e: raise Error(os_error(e)) except UnicodeError as e: raise Error(e, culprit=psf_filepath, codicil=join( 'This is likely a binary PSF file,', 'psf_utils only supports ASCII PSF files.', '\nUse `psf {0!s} {0!s}.ascii` to convert.'.format( psf_filepath), )) meta, types, sweeps, traces, values = sections self.meta = meta self.types = types self.sweeps = sweeps self.traces = traces # add values to sweeps if sweeps: for sweep in sweeps: n = sweep.name sweep.abscissa = np.array([v[0] for v in values[n].values]) # process signals # 1. convert to numpy and delete the original list # 2. convert to Signal class # 3. create signals dictionary signals = {} if traces: traces, groups = traces for trace in traces: name = trace.name type = types.get(trace.type, trace.type) vals = values[name].values if type == 'GROUP': group = { k: types.get(v, v) for k, v in groups[name].items() } prefix = '' get_value = lambda v, i: v[i] elif type.struct: group = type.struct.types prefix = name + ':' get_value = lambda v, i: v[0][i] else: group = {name: type} prefix = '' get_value = lambda v, i: v[i] for i, v in enumerate(group.items()): n, t = v joined_name = prefix + n if 'complex' in t.kind: ordinate = np.array( [complex(*get_value(v, i)) for v in vals]) else: ordinate = np.array([get_value(v, i) for v in vals]) signal = Signal( name=joined_name, ordinate=ordinate, type=t, access=t.name, units=t.units, meta=meta, ) signals[joined_name] = signal del values[name] else: # no traces, this should be a DC op-point analysis dataset for name, value in values.items(): assert len(value.values) == 1 type = types[value.type] if type.struct: for t, v in zip(type.struct.types.values(), value.values[0][0]): n = f'{name}.{t.name}' v = Quantity(v, unicode_units(t.units)) signal = Signal( name=n, ordinate=v, type=t, access=t.name, units=t.units, meta=meta, ) signals[n] = signal else: v = Quantity(value.values[0][0], unicode_units(type.units)) signal = Signal( name=name, ordinate=v, type=type, access=type.name, units=type.units, meta=meta, ) signals[name] = signal self.signals = signals if update_cache: self._write_cache(cache_filepath)