def __init__(self, has_time, datetime_tz):
"""
:param has_time: bool: False if the all-day event
:param datetime_tz: datetime: timezone-aware datetime
"""
assert datetime_tz.tzinfo is not None, 'datetime_tz must be timezone-aware'
CaseClass.__init__(self, ('has_time', has_time), ('datetime_tz', datetime_tz))
def __init__(self, title, command_lines):
"""
:param title:
:param command_lines:
:return:
"""
CaseClass.__init__(self, ('title', title), ('command_lines', command_lines))
def __init__(self,
java_version, # just use for assertion
heap_min=None,
heap_max=None,
perm_min=None,
perm_max=None,
metaspace_min=None,
metaspace_max=None,
new_min=None,
new_max=None,
survivor_ratio=None,
target_survivor_ratio=None):
# constraints
assert perm_min is None or java_version < 1.8, 'java.memory.perm_min is not applicable to java >= 1.8'
assert perm_max is None or java_version < 1.8, 'java.memory.perm_max is not applicable to java >= 1.8'
assert metaspace_min is None or java_version >= 1.8, \
'java.memory.metaspace_min is not applicable to java < 1.8'
assert metaspace_max is None or java_version >= 1.8, \
'java.memory.metaspace_max is not applicable to java < 1.8'
CaseClass.__init__(
self,
('heap_min', heap_min),
('heap_max', heap_max),
('perm_min', perm_min),
('perm_max', perm_max),
('metaspace_min', metaspace_min),
('metaspace_max', metaspace_max),
('new_min', new_min),
('new_max', new_max),
('survivor_ratio', survivor_ratio),
('target_survivor_ratio', target_survivor_ratio)
)
def __init__(self,
home=None,
version=None,
server=None,
memory=None,
jmx=None,
prop=None,
option=None):
# constraints
assert home is not None and os.path.isabs(home), 'java.home is required and must be an absolute path'
assert version is not None, 'java.version is required'
# TODO: check value types and format
assert prop is None or isinstance(prop, dict), 'java.prop must be a dict'
assert option is None or isinstance(option, list), 'java.option must be a list'
CaseClass.__init__(
self,
('home', home),
('version', version),
('server', server),
('memory', JavaSetting.Memory(version, **oget(memory, {}))),
('jmx', JavaSetting.JMX(**oget(jmx, {}))),
('prop', oget(prop, {})),
('option', oget(option, [])),
)
def __init__(self,
i18n=messages_en,
stdin=sys.stdin,
stdout=sys.stdout,
stderr=sys.stderr):
CaseClass.__init__(self, ('i18n', i18n), ('stdin', stdin),
('stdout', stdout), ('stderr', stderr))
def __init__(self,
start_time,
end_time,
summary,
creator_name=None,
creator_email=None,
location=None):
"""
:param start_time: EventTime:
:param end_time: EventTime:
:param summary: unicode:
:param creator_name: unicode:
:param creator_email: unicode:
:param location: unicode:
"""
assert isinstance(start_time, EventTime)
assert isinstance(end_time, EventTime)
assert start_time.has_time == end_time.has_time
assert start_time <= end_time
CaseClass.__init__(self,
('start_time', start_time),
('end_time', end_time),
('summary', summary),
('creator_name', creator_name),
('creator_email', creator_email),
('location', location)
)
def __init__(self, cmd, meta, encoding='utf-8'):
"""
:param cmd: command line string
:param meta:
:param encoding: encoding for command line string
:return:
"""
CaseClass.__init__(self, ('cmd', cmd), ('meta', meta), ('encoding', encoding))
def __init__(self, home, console=None, gc=None, dump=None, error=None):
CaseClass.__init__(
self,
('console', LogSetting.Console(home, **oget(console, {}))),
('gc', LogSetting.GC(home, **oget(gc, {}))),
('dump', LogSetting.Dump(home, **oget(dump, {}))),
('error', LogSetting.Error(home, **oget(error, {}))),
)
def __init__(self, user=None, env=None):
# constraints
assert user is not None, "os.user is required"
assert isinstance(user, six.string_types), "os.user must be a string"
assert env is None or isinstance(env, dict), "os.env must be a dict"
d = dict((k, str(v)) for k, v in oget(env, {}).items())
CaseClass.__init__(self, ("user", user), ("env", d))
def __init__(self, title, command_lines):
"""
:param title:
:param command_lines:
:return:
"""
CaseClass.__init__(self, ('title', title),
('command_lines', command_lines))
def __init__(self, work_dir=None, env=None, lock=False):
"""
:param work_dir:
:param env:
:param lock:
:return:
"""
env = env or {}
CaseClass.__init__(self, ('work_dir', work_dir), ('env', env), ('lock', lock))
def __init__(self, home, prefix=None, max_size=None, backup=None, preserve=None):
# constraints
assert backup is None or isinstance(backup, int), 'log.console.backup must be an integer'
assert preserve is None or isinstance(backup, int), 'log.console.preserve must be an integer'
CaseClass.__init__(
self,
('prefix', omap(lambda p: normalize_path(p, home), prefix)),
('max_size', omap(DataSize, max_size)),
('backup', backup),
('preserve', preserve))
def __init__(self, size):
if isinstance(size, int) or size.isdigit():
value = int(size)
scale = ''
else:
val, last = size[:-1], size[-1:]
assert last.lower() in self._scales.keys(), 'Unknown scale: %s' % last
assert val.isdigit(), 'Size must be an integer: %s' % val
value = int(val)
scale = last
CaseClass.__init__(self, ('value', value), ('scale', scale))
def __init__(self, term_type=None, encoding=None,
stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr,
getch_repeat_threshold=DEFAULT_GETCH_REPEAT_THRESHOLD,
keep_input_clean=True, getch_enabled=True):
CaseClass.__init__(self,
('term_type', term_type or self._detect_term_type()),
('encoding', encoding or self._detect_encoding(stdout)),
('stdin', stdin),
('stdout', stdout),
('stderr', stderr),
('getch_repeat_threshold', getch_repeat_threshold),
('keep_input_clean', keep_input_clean),
('getch_enabled', getch_enabled and self._can_getch_enable(stdin))
)
self.restore_terminal = self._get_restore_function() # binary function for restoring terminal attributes
self.last_getch_time = 0.0
self.last_getch_char = '..'
def __init__(self, name=None, home=None, jar=None, entry_point=None, command=None, pid_file=None):
# constraints
assert name is not None, 'app.name is required'
assert home is not None, 'app.home is required'
assert os.path.isabs(home), 'app.home must be an absolute path'
assert (jar is None) != (command is None), 'Either app.jar or app.command but not both must be given'
assert jar is not None or entry_point is None, 'app.entry_point must be used with app.jar'
normalize = lambda p: normalize_path(p, home)
CaseClass.__init__(
self,
('name', name),
('home', home),
('jar', omap(normalize, jar)),
('entry_point', entry_point),
('command', omap(normalize, command)),
('pid_file', omap(normalize, pid_file))
)
def __init__(self, config_path=None, work_dir=None, root_menu=None, encoding=None, lang=None, width=None,
clear_cache=False, cache_dir=EVAL_CACHE_DIR, pid_dir=COMMAND_PID_DIR,
stdin=None, stdout=None, stderr=None, getch_enabled=True, source_enabled=True):
is_url = Loader.is_url(config_path)
work_dir = omap(lambda s: to_unicode(s, encoding), self._search_work_dir(work_dir, config_path, is_url))
CaseClass.__init__(self,
('config_path', config_path),
('work_dir', work_dir),
('root_menu', oget(root_menu, {})),
('encoding', encoding),
('lang', self._find_lang(lang)),
('width', width),
('clear_cache', clear_cache),
('cache_dir', cache_dir),
('pid_dir', pid_dir),
('stdin', oget(stdin, sys.stdin)),
('stdout', oget(stdout, sys.stdout)),
('stderr', oget(stderr, sys.stderr)),
('getch_enabled', getch_enabled),
('source_enabled', source_enabled)
)
def __init__(self,
config_path=None,
extra_args=None,
dry_run=False,
debug=False,
app_setting=None,
java_setting=None,
log_setting=None,
os_setting=None,
pre_commands=None,
post_commands=None):
"""
:param config_path:
:param extra_args: arguments for Java application
:param dry_run:
:param debug: debug mode if true
:param app_setting:
:param java_setting:
:param log_setting:
:param os_setting:
:param pre_commands:
:param post_commands:
:return:
"""
CaseClass.__init__(
self,
('config_path', config_path),
('extra_args', oget(extra_args, [])),
('dry_run', dry_run),
('debug', debug),
('app_setting', app_setting),
('java_setting', java_setting),
('log_setting', log_setting),
('os_setting', os_setting),
('pre_commands', oget(pre_commands, [])),
('post_commands', oget(post_commands, []))
)
def __init__(self, home, path=None):
CaseClass.__init__(self, ('path', omap(lambda p: normalize_path(p, home), path)))
def __init__(self, home, prefix=None):
CaseClass.__init__(self, ('prefix', omap(lambda p: normalize_path(p, home), prefix)))
def __init__(self, port=None, ssl=None, authenticate=None):
CaseClass.__init__(self, ('port', port), ('ssl', ssl),
('authenticate', authenticate))
def __init__(self, operation=None, now=None, debug=None):
CaseClass.__init__(self,
('operation', operation),
('now', now or get_localzone().localize(datetime.now())),
('debug', debug)
)
def __init__(self, port=None, ssl=None, authenticate=None):
CaseClass.__init__(self, ('port', port), ('ssl', ssl), ('authenticate', authenticate))
def __init__(self, setting, logger, failed=False):
CaseClass.__init__(self, ('setting', setting), ('logger', logger), ('failed', failed))
def __init__(self, ident):
"""
:param ident: identity for logger
"""
CaseClass.__init__(self, ('ident', ident))
def __init__(self):
CaseClass.__init__(self, x=123, y=45)
def __init__(self, c):
CaseClass.__init__(self, ('c', c))
