def __init__(self, model=None, offsets=None, settings=None, variant='HIT'):
"""Initialize new library instance with no interface instances."""
if settings is None:
settings = {}
self.params = dicti()
self.sd_values = dicti()
self.sd_cache = TimeoutCache(self._get_jittered_sd,
timeout=settings.get(
'shot_interval', 1.0))
self.model = model
self.offsets = {} if offsets is None else offsets
self.settings = settings
self.jitter = settings.get('jitter', True)
self.auto_sd = settings.get('auto_sd', True)
self._variant = variant
def test_all_args(self):
el0 = madseq.Element(None, None, odicti(a='a0', b='b0', c='c0'))
el1 = madseq.Element(None, None, odicti(a='a1', b='b1', d='d1'), el0)
el2 = madseq.Element(None, None, odicti(a='a2'), el1)
self.assertEqual(el2.all_args,
dicti([('c', 'c0'), ('b', 'b1'),
('d', 'd1'), ('a', 'a2')]))
def __init__(self,
lib,
params,
model=None,
offsets=None,
settings=None,
control=None):
self._lib = lib
self._params = dicti({
'beam_energy':
dict(name='beam_energy',
ui_name='beam_energy',
ui_hint='',
ui_prec=3,
unit='MeV/u',
ui_unit='MeV/u',
ui_conv=1),
'beam_focus':
dict(name='beam_focus',
ui_name='beam_focus',
ui_hint='',
ui_prec=3,
unit='m',
ui_unit='mm',
ui_conv=1000),
'beam_intensity':
dict(name='beam_intensity',
ui_name='beam_intensity',
ui_hint='',
ui_prec=3,
unit='',
ui_unit='',
ui_conv=1),
'gantry_angle':
dict(name='gantry_angle',
ui_name='gantry_angle',
ui_hint='',
ui_prec=3,
unit='°',
ui_unit='°',
ui_conv=1),
})
self._params.update(params)
self._model = model
self._offsets = {} if offsets is None else offsets
self.connected = Bool(False)
self.settings = settings
self.control = control
self.vAcc = -1
def __init__(self, entry, format, group_names, groups):
#: The original logfile entry with trailing newlines removed
self.entry = entry
#: The entry's log format string
self.format = format
#: .. versionadded:: 0.3.0
#:
#: A `dict` mapping individual log format directives (e.g., ``"%h"`` or
#: ``"%<s"``) to their corresponding values from the log entry.
#: ``%{*}t`` directives with multiple subdirectives (e.g.,
#: ``%{%Y-%m-%d}t``) are broken up into one entry per subdirective (For
#: ``%{%Y-%m-%d}t``, this would become the three keys ``"%{%Y}t"``,
#: ``"%{%m}t"``, and ``"%{%d}t"``). This attribute provides an
#: alternative means of looking up directive values besides using the
#: named attributes.
self.directives = {}
for (k, drct), v in zip(group_names, groups):
d = self.__dict__
if isinstance(k, tuple):
for i, k2 in enumerate(k[:-1]):
if i == 0 and k2 in NOCASEDICTS:
subd = dicti()
else:
subd = {}
d = d.setdefault(k2, subd)
k = k[-1]
if d.get(k) is None:
d[k] = v
#else: Assume d[k] == v
self.directives[drct] = v
for prefix in ('original_', '', 'final_'):
for midfix in ('begin_', '', 'end_'):
target = prefix + midfix + 'request_time'
if getattr(self, target + '_fields', None):
setattr(
self,
target,
assemble_datetime(getattr(self, target + '_fields')),
)
},
'C': ('cookies', cookie_value),
'e': ('env_vars', clf_string),
'h': {
'c': ('remote_underlying_host', esc_string),
},
'i': ('headers_in', clf_string),
# `%{c}L` is derived the same way as `%L`; see above.
'L': {
'c': ('connection_log_id', clf(FieldType(r'[-@/+A-Za-z0-9]+', str))),
},
'n': ('notes', clf_string),
'o': ('headers_out', clf_string),
'p': dicti({
'canonical': ('server_port', integer),
'local': ('local_port', integer),
'remote': ('remote_port', integer),
}),
'P': dicti({
'pid': ('pid', integer),
# `%{tid}P` is formatted as an unsigned integer.
'tid': ('tid', uinteger),
'hextid': ('tid', FieldType(r'[0-9A-Fa-f]+', lambda s: int(s, 16))),
}),
't': strftime2regex,
'T': dicti({
'ms': ('request_duration_milliseconds', integer),
'us': ('request_duration_microseconds', integer),
's': ('request_duration_seconds', integer),
}),
'^ti': ('trailers_in', clf_string),
def set_sd_values(self, data):
self.sd_values = dicti(data)
self.auto_sd = False
def __init__(self, units):
"""Store Madx instance for later use."""
self._units = dicti(units)
"C": ("cookies", cookie_value),
"e": ("env_vars", clf_string),
"h": {
"c": ("remote_underlying_host", esc_string),
},
"i": ("headers_in", clf_string),
# `%{c}L` is derived the same way as `%L`; see above.
"L": {
"c": ("connection_log_id", clf(FieldType(r"[-@/+A-Za-z0-9]+", str))),
},
"n": ("notes", clf_string),
"o": ("headers_out", clf_string),
"p":
dicti({
"canonical": ("server_port", integer),
"local": ("local_port", integer),
"remote": ("remote_port", integer),
}),
"P":
dicti({
"pid": ("pid", integer),
# `%{tid}P` is formatted as an unsigned integer.
"tid": ("tid", uinteger),
"hextid": ("tid", FieldType(r"[0-9A-Fa-f]+", lambda s: int(s, 16))),
}),
"t":
strftime2regex,
"T":
dicti({
"ms": ("request_duration_milliseconds", integer),
"us": ("request_duration_microseconds", integer),
def transform(self, node_transform):
"""Create a new transformed document using the node_transform."""
defs = dicti()
return Document(node_transform(node, defs)
for node in self._nodes)
def load_dvm_parameters():
blob = read_binary('hit_acs', 'DVM-Parameter_v2.10.0-HIT.csv')
parlist = load_csv(blob.splitlines(), 'utf-8')
return dicti({p['name']: p for p in parlist})
