def test_get_detail_title():
testobj = None
assert funcs.get_detail_title('gebrtaak', 'new', testobj) == 'Nieuw(e) gebruikerstaak'
testobj = NS(naam='testnaam')
assert funcs.get_detail_title('gebrtaak', '', testobj) == 'Gebruikerstaak testnaam'
testobj = NS(nummer='testnummer')
assert funcs.get_detail_title('gebrtaak', '', testobj) == 'Gebruikerstaak testnummer'
def __init__(self,
x='identity',
y='identity',
xlim=None,
ylim=None,
expand=True):
self.trans = NS(x=gettrans(x), y=gettrans(y))
self.limits = NS(x=xlim, y=ylim)
self.expand = expand
def read_codefiles(self):
files = {
variant: self.module.__file__ if variant == "main" else
self.tmod.transfer(f"{self.basename}:{variant}")[1]
for variant in self.variants
}
self.files = NS(**files)
self.cf = NS(
**{
variant: CodeFile(file, self.module.__name__)
for variant, file in files.items()
})
def parse_conn_str(cs, scheme="http"):
"""
Parse a connection string into a namespace
"""
url = NS()
parts = urlparse(cs.strip(), scheme=scheme)
url.scheme = parts.scheme
if url.scheme not in ("http", "https", ):
raise ValueError(f"Unsupported scheme '{url.scheme}'")
username = unquote(parts.username or "").strip()
url.username = username or None
password = unquote(parts.password or "").strip()
url.password = password or None
if (url.username is None) ^ (url.password is None):
raise ValueError("Incomplete login credentials'")
url.hostname = parts.hostname
if url.hostname is None:
raise ValueError("Missing hostname")
url.port = parts.port
url.domain = parts.path.lstrip("/")
if url.domain == "":
url.domain = "default"
return url
def view(self, limits=None, range=None):
"""
Information about the trained scale
"""
if limits is None:
limits = self.limits
if range is None:
range = self.dimension(limits=limits)
breaks = self.get_breaks(range)
breaks = breaks.compress(np.isfinite(breaks))
minor_breaks = self.get_minor_breaks(breaks, range)
mask = (range[0] <= breaks) & (breaks <= range[1])
breaks = breaks.compress(mask)
labels = self.get_labels(breaks, mask)
if minor_breaks is None:
minor_breaks = []
vs = NS(scale=self,
aesthetics=self.aesthetics,
name=self.name,
limits=limits,
range=range,
breaks=breaks,
labels=labels,
minor_breaks=minor_breaks)
return vs
def function(self, meta, precision):
data = Variable('data_p', 'const void *')
back = Variable('back_p', 'void *')
meta = NS(precision=precision, **meta.__dict__)
return Function(name=self.name,
arguments=ArgumentList(data, back),
meta=meta)
def view(self, limits=None, range=None):
"""
Information about the trained scale
"""
if limits is None:
limits = self.limits
if range is None:
range = self.dimension(limits=limits)
breaks_d = self.get_breaks(limits)
breaks = self.map(pd.Categorical(breaks_d.keys()))
minor_breaks = []
labels = self.get_labels(breaks_d)
vs = NS(
scale=self,
aesthetics=self.aesthetics,
name=self.name,
limits=limits,
range=range,
breaks=breaks,
labels=labels,
minor_breaks=minor_breaks
)
return vs
def expand_limits(self, limits, expand=None, coord_limits=None,
trans=None):
"""
Calculate the final range in coordinate space
"""
expand_func = partial(scale_continuous.expand_limits, self,
trans=trans)
n_limits = len(limits)
range_c = (0, 1)
range_d = (1, n_limits)
is_only_continuous = n_limits == 0
if hasattr(self.range, 'range_c'):
is_only_discrete = self.range.range_c.range is None
range_c = self.range.range_c.range
else:
is_only_discrete = True
if self.is_empty():
return expand_func(range_c, expand, coord_limits),
elif is_only_continuous:
return expand_func(range_c, expand, coord_limits)
elif is_only_discrete:
return expand_func(range_d, expand, coord_limits)
else:
no_expand = self.default_expand(0, 0)
ranges_d = expand_func(range_d, expand, coord_limits)
ranges_c = expand_func(range_c, no_expand, coord_limits)
limits = np.hstack(ranges_d.range, ranges_c.range)
range = (np.min(limits), np.max(limits))
ranges = NS(range=range, range_coord=range)
return ranges
def init_torch(
# Seed to use for random numbers
seed: Argument & int = default(1234),
# Use CUDA for this model
cuda: Argument & bool = default(None),
# Number of threads for PyTorch
workers: Argument & int = default(None),
):
np.random.seed(seed)
torch.manual_seed(seed)
torch.set_num_threads(workers or 1)
if cuda is None:
cuda = torch.cuda.is_available()
if cuda:
torch.cuda.manual_seed_all(seed)
return NS(
device=torch.device("cuda" if cuda else "cpu"),
cuda=cuda,
sync=torch.cuda.synchronize if cuda else None,
workers=workers,
seed=seed,
)
def add(name, scheme, pool=None):
functions.append(
Function(name=name,
arguments=ArgumentList(data, back),
meta=NS(length=length,
precision=precision,
scheme=scheme,
pool=pool)))
def list_new_large_kernels():
"""Return list of large kernels to generate with the new generator."""
kernels = [
NS(length=50,
factors=[10, 5],
use_3steps_large_twd={
'sp': 'true',
'dp': 'true'
},
threads_per_block=256),
NS(length=64,
factors=[8, 8],
use_3steps_large_twd={
'sp': 'true',
'dp': 'false'
}),
NS(length=81,
factors=[3, 3, 3, 3],
use_3steps_large_twd={
'sp': 'true',
'dp': 'true'
}),
NS(length=100,
factors=[5, 5, 4],
use_3steps_large_twd={
'sp': 'true',
'dp': 'false'
}),
NS(length=128,
factors=[8, 4, 4],
use_3steps_large_twd={
'sp': 'true',
'dp': 'false'
}),
NS(length=200,
factors=[8, 5, 5],
use_3steps_large_twd={
'sp': 'false',
'dp': 'false'
}),
NS(length=256,
factors=[4, 4, 4, 4],
use_3steps_large_twd={
'sp': 'true',
'dp': 'true'
})
]
# for SBCC kernel, increase desired threads_per_block so that columns per
# thread block is also increased. currently targeting for 16 columns
block_width = 16
for k in kernels:
k.scheme = 'CS_KERNEL_STOCKHAM_BLOCK_CC'
if not hasattr(k, 'threads_per_block'):
k.threads_per_block = block_width * reduce(mul, k.factors,
1) // min(k.factors)
return kernels
def test_dynamic_configuration(notes: Path) -> None:
import pytz
from types import SimpleNamespace as NS
from my.core.cfg import tmp_config
with tmp_config() as C:
C.orgmode = NS(paths=[notes])
# TODO ugh. this belongs to tz provider or global config or someting
C.weight = NS(default_timezone=pytz.timezone('Europe/London'))
from my.body.weight import from_orgmode
weights = [0.0 if isinstance(x, Exception) else x.value for x in from_orgmode()]
assert weights == [
0.0,
62.0,
0.0,
61.0,
62.0,
0.0,
]
def pytorch_reader(dataset, transform):
rval = NS()
manifest = dataset["manifest"]
assert all("partition" in entry
for entry in manifest) or len(manifest) == 1
for entry in manifest:
if "partition" not in entry:
return _load(dataset["environment"], entry, transform)
else:
setattr(rval, entry["partition"],
_load(dataset["environment"], entry, transform))
return rval
def _testSingleRule(self,
rule_lines,
target_types,
labelstr,
conditions=None,
flags=None):
if isinstance(rule_lines, str):
rule_lines = (rule_lines, )
if flags is None:
flags = NS(alert=False, halt=False)
R, = list(parserules(rule_lines))
D("R = %s", R)
self.assertEqual(len(R.targets), len(target_types))
for T, Ttype in zip(R.targets, target_types):
self.assertIsInstance(T, Ttype)
self.assertEqual(R.label, labelstr)
self.assertEqual(R.flags.alert, flags.alert)
self.assertEqual(R.flags.halt, flags.halt)
if conditions is not None:
self.assertEqual(len(R.conditions), len(conditions))
for i in range(len(conditions)):
C = conditions[i]
RC = R.conditions[i]
D("C = %s", C)
for attr in dir(C):
if attr[0].isalpha():
D("test attr %s: %s VS %s", attr, getattr(C, attr),
getattr(RC, attr))
if attr == 'flags':
Cflags = C.flags
RCflags = RC.flags
for flag_name in dir(RC.flags):
if flag_name == 'D':
continue
if flag_name[0].isalpha():
if getattr(RCflags, flag_name):
self.assertTrue(
flag_name in Cflags,
"\"%s\" in Rule but not expected" %
(flag_name, ))
else:
self.assertTrue(
flag_name not in Cflags,
"\"%s\" expected, but not in Rule"
% (flag_name, ))
else:
av1 = getattr(C, attr)
av2 = getattr(RC, attr)
if not callable(av1) and not callable(av2):
self.assertEqual(getattr(C, attr),
getattr(RC, attr))
def setup_panel_params(self, scale_x, scale_y):
"""
Compute the range and break information for the panel
"""
def get_view_limits(scale, coord_limits):
expansion = scale.default_expansion(expand=self.expand)
ranges = scale.expand_limits(scale.limits, expansion, coord_limits,
identity_trans)
vs = scale.view(limits=coord_limits, range=ranges.range)
return vs
out = NS(x=get_view_limits(scale_x, self.limits.x),
y=get_view_limits(scale_y, self.limits.y))
return out
def add(name, scheme, pool=None):
use3Steps = {'sp': 'true', 'dp': 'true'}
if length == 81:
use3Steps['dp'] = 'false'
elif length == 200:
use3Steps['sp'] = use3Steps['dp'] = 'false'
functions.append(
Function(name=name,
arguments=ArgumentList(data, back),
meta=NS(length=length,
precision=precision,
scheme=scheme,
use_3steps_large_twd=use3Steps,
pool=pool)))
def _draw_labels(self):
"""
Draw x and y labels onto the figure
"""
# This is very laboured. Should be changed when MPL
# finally has a constraint based layout manager.
figure = self.figure
get_property = self.theme.themeables.property
try:
margin = get_property('axis_title_x', 'margin')
except KeyError:
pad_x = 5
else:
pad_x = margin.get_as('t', 'pt')
try:
margin = get_property('axis_title_y', 'margin')
except KeyError:
pad_y = 5
else:
pad_y = margin.get_as('r', 'pt')
# Get the axis labels (default or specified by user)
# and let the coordinate modify them e.g. flip
labels = self.coordinates.labels(
NS(x=self.layout.xlabel(self.labels),
y=self.layout.ylabel(self.labels)))
# The first axes object is on left, and the last axes object
# is at the bottom. We change the transform so that the relevant
# coordinate is in figure coordinates. This way we take
# advantage of how MPL adjusts the label position so that they
# do not overlap with the tick text. This works well for
# facetting with scales='fixed' and also when not facetting.
# first_ax = self.axs[0]
# last_ax = self.axs[-1]
xlabel = self.facet.last_ax.set_xlabel(labels.x, labelpad=pad_x)
ylabel = self.facet.first_ax.set_ylabel(labels.y, labelpad=pad_y)
xlabel.set_transform(
mtransforms.blended_transform_factory(
figure.transFigure, mtransforms.IdentityTransform()))
ylabel.set_transform(
mtransforms.blended_transform_factory(
mtransforms.IdentityTransform(), figure.transFigure))
figure._themeable['axis_title_x'] = xlabel
figure._themeable['axis_title_y'] = ylabel
def get_vehicle_status(self):
command = '/-/vehicle-info/get-vehicle-details'
r = self.session.post(self.url + command,
headers=carnet.request_headers)
data = r.json()
vehicle_data = data['vehicleDetails']
mileage = vehicle_data['distanceCovered'].replace('.', '')
service_components = vehicle_data['serviceInspectionData'].split()
service_in_days = service_components[0]
service_in_km = service_components[3].replace('.', '')
self.odometer_values = NS(mileage=mileage,
service_in_km=service_in_km,
service_in_days=service_in_days)
self.reveal(self.odometer, f'{mileage}', title='Matka km')
self.display_odometer = True
def expand_limits(self,
limits,
expand=None,
coord_limits=None,
trans=None):
"""
Calculate the final range in coordinate space
"""
if limits is None:
limits = (None, None)
if coord_limits is None:
coord_limits = (None, None)
if trans is None:
trans = self.trans
def _expand_range_distinct(x, expand):
# Expand ascending and descending order range
if x[0] > x[1]:
x = expand_range_distinct(x[::-1], expand)[::-1]
else:
x = expand_range_distinct(x, expand)
return x
# - Override None in coord_limits
# - Expand limits in coordinate space
# - Remove any computed infinite values &
# fallback on unexpanded limits
limits = tuple(l if cl is None else cl
for cl, l in zip(coord_limits, limits))
limits_coord_space = trans.transform(limits)
range_coord = _expand_range_distinct(limits_coord_space, expand)
with ignore_warnings(RuntimeWarning):
# Consequences of the runtimewarning (NaNs and infs)
# are dealt with below
final_limits = trans.inverse(range_coord)
final_range = tuple([
fl if np.isfinite(fl) else l
for fl, l in zip(final_limits, limits)
])
ranges = NS(range=final_range, range_coord=range_coord)
return ranges
def _make_group(self, g, entries):
valid = True
ws = WorkSet([g])
# Set of graphs that must all be augmented with the same fvs
eqv = OrderedSet([g])
# Call sites that will have to be updated
call_sites = {}
for currg in ws:
eqv.add(currg)
new_results = self.call_sites(currg)
if new_results is None:
valid = False
break
for _, new_eqv in new_results.items():
ws.queue_all(new_eqv)
call_sites.update(new_results)
if valid:
for gg in eqv:
entries[gg] = NS(graph=gg, calls=call_sites, eqv=eqv)
# Only the first graph gets the call sites
call_sites = {}
def setup_panel_params(self, scale_x, scale_y):
"""
Compute the range and break information for the panel
"""
def get_view_limits(scale, coord_limits, trans):
if coord_limits:
coord_limits = trans.transform(coord_limits)
expansion = scale.default_expansion(expand=self.expand)
ranges = scale.expand_limits(scale.limits, expansion, coord_limits,
trans)
vs = scale.view(limits=coord_limits, range=ranges.range)
vs.range = np.sort(ranges.range_coord)
vs.breaks = transform_value(trans, vs.breaks, vs.range)
vs.minor_breaks = transform_value(trans, vs.minor_breaks, vs.range)
return vs
out = NS(x=get_view_limits(scale_x, self.limits.x, self.trans.x),
y=get_view_limits(scale_y, self.limits.y, self.trans.y))
return out
def main(exp):
# dataset to use
dataset: Argument
# batch size
batch_size: Argument & int = default(32)
# path to model checkpoint file
checkpoint: Argument = default(None)
torch_settings = init_torch()
wrapper = iteration_wrapper(exp, sync=torch_settings.sync)
args = NS(
dataset=dataset,
checkpoint=checkpoint,
batch_size=batch_size,
torch_settings=torch_settings,
wrapper=wrapper,
)
train300_mlperf_coco(exp, args)
def range(self, panel_params):
"""
Return the range along the dimensions of the coordinate system
"""
# Defaults to providing the 2D x-y ranges
return NS(x=panel_params.x.range, y=panel_params.y.range)
def list_new_kernels():
"""Return list of kernels to generate with the new generator."""
# remaining lenghts less than 1024: 121 192 224 250 320 336 375
# 384 405 432 450 480 500 512 576 600 625 640 675 750 768 800 810
# 864 900 972 1000
# dictionary of (flavour, threads_per_block) -> list of kernels to generate
all_kernels = {
('uwide', 256): [
# NS(length=2, factors=[2]),
# NS(length=3, factors=[3]),
# NS(length=5, factors=[5]),
# NS(length=6, factors=[6]),
# NS(length=7, factors=[7]),
# NS(length=8, factors=[8]),
NS(length=9, factors=[3, 3]),
# NS(length=10, factors=[10]),
NS(length=12, factors=[6, 2]),
NS(length=14, factors=[7, 2]),
NS(length=15, factors=[5, 3]),
# NS(length=18, factors=[6,3]),
NS(length=20, factors=[10, 2]),
NS(length=21, factors=[7, 3]),
NS(length=24, factors=[8, 3]),
NS(length=25, factors=[5, 5]),
# NS(length=27, factors=[3,3,3]),
NS(length=28, factors=[7, 4]),
NS(length=30, factors=[10, 3]),
NS(length=36, factors=[6, 6]),
NS(length=42, factors=[7, 6]),
NS(length=45, factors=[5, 3, 3]),
# NS(length=49, factors=[7,7]),
NS(length=50, factors=[10, 5]),
NS(length=54, factors=[6, 3, 3]),
NS(length=56, factors=[8, 7]),
# NS(length=64, factors=[16,4]),
# NS(length=72, factors=[8,3,3]),
NS(length=75, factors=[5, 5, 3]),
NS(length=80, factors=[16, 5]),
# NS(length=81, factors=[3,3,3,3]),
# NS(length=96, factors=[16,6]),
# NS(length=100, factors=[10,10]),
NS(length=108, factors=[6, 6, 3]),
NS(length=112, factors=[16, 7]),
NS(length=125, factors=[5, 5, 5]),
# NS(length=128, factors=[16,8]),
# NS(length=135, factors=[5,3,3,3]),
# NS(length=150, factors=[10,5,3]),
NS(length=160, factors=[16, 10]),
# NS(length=162, factors=[6,3,3,3]),
NS(length=168, factors=[8, 7, 3]),
NS(length=180, factors=[10, 6, 3]),
# NS(length=216, factors=[8,3,3,3]),
NS(length=225, factors=[5, 5, 3, 3]),
NS(length=240, factors=[16, 5, 3]),
# NS(length=243, factors=[3,3,3,3,3]),
# NS(length=256, factors=[16,16]),
# NS(length=270, factors=[10,3,3,3]),
# NS(length=288, factors=[16,6,3]),
NS(length=324, factors=[6, 6, 3, 3]),
NS(length=343, factors=[7, 7, 7]),
NS(length=360, factors=[10, 6, 6]),
NS(length=400, factors=[16, 5, 5]),
# NS(length=486, factors=[6,3,3,3,3]),
# NS(length=540, factors=[10,6,3,3]),
NS(length=648, factors=[8, 3, 3, 3, 3]),
NS(length=720, factors=[16, 5, 3, 3]),
# NS(length=729, factors=[3,3,3,3,3,3]),
NS(length=960, factors=[16, 10, 6]),
],
('wide', 64): [
# NS(length=11, factors=[11]),
NS(length=22, factors=[2, 11]),
NS(length=44, factors=[4, 11]),
NS(length=60, factors=[6, 10]),
NS(length=84, factors=[2, 6, 7]),
NS(length=90, factors=[3, 3, 10]),
NS(length=120, factors=[2, 6, 10]),
# NS(length=200, factors=[2,10,10]),
NS(length=300, factors=[3, 10, 10]),
],
('uwide', 64): [
NS(length=32, factors=[16, 2]),
NS(length=40, factors=[10, 4]),
NS(length=48, factors=[3, 4, 4]),
NS(length=88, factors=[11, 8]),
NS(length=176, factors=[16, 11]),
NS(length=336, factors=[7, 8, 6]),
],
# ('tall', X): [
# NS(length=4),
# NS(length=13),
# NS(length=16),
# NS(length=26),
# NS(length=52),
# NS(length=104),
# NS(length=169),
# NS(length=192),
# NS(length=208),
# NS(length=320),
# NS(length=512),
# NS(length=625),
# NS(length=864),
# NS(length=1000),
# ]
}
expanded = []
for params, kernels in all_kernels.items():
flavour, threads_per_block = params
expanded.extend(
NS(**kernel.__dict__,
flavour=flavour,
threads_per_block=threads_per_block,
scheme='CS_KERNEL_STOCKHAM') for kernel in kernels)
return expanded
def t(self):
ts = NS()
for tbl in self.tables:
setattr(ts, tbl.name, tbl)
return ts
import unittest
from kalliopepbx.utils import parse_conn_str
from types import SimpleNamespace as NS
test_values = [
('http://example.com',
NS(domain='default',
hostname='example.com',
password=None,
port=None,
scheme='http',
username=None)),
('https://example.com',
NS(domain='default',
hostname='example.com',
password=None,
port=None,
scheme='https',
username=None)),
('http://example.com/default',
NS(domain='default',
hostname='example.com',
password=None,
port=None,
scheme='http',
username=None)),
('http://example.com:8080/default',
NS(domain='default',
hostname='example.com',
password=None,
port=8080,
# FFprobe/FFmpeg Settings
threads = "8" # The number of cores/threads your CPU has. Probably 4.
ffprobeLocation = "ffprobe" # Change this if ffprobe isn't in your path.
# ffprobeLocation = os.path.realpath("./ffprobe") # If you have ffprobe as a local binary.
ffmpegLocation = "ffmpeg" # Change this if ffmpeg isn't in your path.
# ffmpegLocation = os.path.realpath("./ffmpeg") # If you have ffmpeg as a local binary.
# The directories where everything is and should be located.
_baseDir = os.path.abspath(
os.path.join(os.path.sep, "mnt", "sdb", "openings.moe"))
_deployDir = os.path.join(_baseDir, "deploy")
directories = NS(text=os.path.join(_baseDir, "bin"),
source=os.path.join(_baseDir, "source"),
encode=os.path.join(_baseDir, "encode"),
deploy=NS(videos=os.path.join(_deployDir, "videos"),
fonts=os.path.join(_deployDir, "fonts"),
subtitles=os.path.join(_deployDir, "subtitles")),
attachments=os.path.join(_baseDir, "attachments"))
# Video Settings
video = NS(
default=NS(bitrate="3000K",
crf="18",
maxBitrate="5000k",
maxWidth=1280,
maxHeight=720),
# VP9 Configuration
VP9=NS(
slices="4",
def setup_logging(
cmd_name=None,
main_log=None,
format=None,
level=None,
flags=None,
upd_mode=None,
ansi_mode=None,
trace_mode=None,
module_names=None,
function_names=None,
verbose=None,
supplant_root_logger=False,
):
''' Arrange basic logging setup for conventional UNIX command
line error messaging; return an object with informative attributes.
That object is also available as the global `cs.logutils.loginfo`.
Amongst other things, the default logger now includes
the `cs.pfx` prefix in the message.
This function runs in two modes:
- if logging has not been set up, it sets up a root logger
- if the root logger already has handlers,
monkey patch the first handler's formatter to prefix the `cs.pfx` state
Parameters:
* `cmd_name`: program name, default from `basename(sys.argv[0])`.
Side-effect: sets `cs.pfx.cmd` to this value.
* `main_log`: default logging system.
If `None`, the main log will go to `sys.stderr`;
if `main_log` is a string, is it used as a filename to
open in append mode;
otherwise main_log should be a stream suitable
for use with `logging.StreamHandler()`.
The resulting log handler is added to the `logging` root logger.
* `format`: the message format for `main_log`.
If `None`, use `DEFAULT_PFX_FORMAT_TTY`
when `main_log` is a tty or FIFO,
otherwise `DEFAULT_PFX_FORMAT`.
* `level`: `main_log` logging level.
If `None`, infer a level from the environment
using `infer_logging_level()`.
* `flags`: a string containing debugging flags separated by commas.
If `None`, infer the flags from the environment using
`infer_logging_level()`.
The following flags have meaning:
`D`: set cs.logutils.D_mode to True;
`TDUMP`: attach a signal handler to SIGHUP to do a thread stack dump;
`TRACE`: enable various noisy tracing facilities;
`UPD`, `NOUPD`: set the default for `upd_mode` to True or False respectively.
* `upd_mode`: a Boolean to activate cs.upd as the `main_log` method;
if `None`, set it to `True` if `flags` contains 'UPD',
otherwise to `False` if `flags` contains 'NOUPD',
otherwise set it from `main_log.isatty()`.
A true value causes the root logger to use `cs.upd` for logging.
* `ansi_mode`: if `None`,
set it from `main_log.isatty() and not cs.colourise.env_no_color()`,
which thus honours the `$NO_COLOR` environment variable
(see https://no-color.org/ for the convention).
A true value causes the root logger to colour certain logging levels
using ANSI terminal sequences (currently only if `cs.upd` is used).
* `trace_mode`: if `None`, set it according to the presence of
'TRACE' in flags. Otherwise if `trace_mode` is true, set the
global `loginfo.trace_level` to `loginfo.level`; otherwise it defaults
to `logging.DEBUG`.
* `verbose`: if `None`, then if stderr is a tty then the log
level is `INFO` otherwise `WARNING`. Otherwise, if `verbose` is
true then the log level is `INFO` otherwise `WARNING`.
'''
global D_mode, loginfo # pylint: disable=global-statement
# infer logging modes, these are the initial defaults
inferred = infer_logging_level(verbose=verbose)
if level is None:
level = inferred.level
if flags is None:
flags = inferred.flags
if module_names is None:
module_names = inferred.module_names
if function_names is None:
function_names = inferred.function_names
if cmd_name is None:
cmd_name = os.path.basename(sys.argv[0])
cs.pfx.cmd = cmd_name
if main_log is None:
main_log = sys.stderr
elif isinstance(main_log, str):
main_log = open(main_log, "a")
# determine some attributes of main_log
try:
fd = main_log.fileno()
except (AttributeError, IOError):
is_fifo = False
##is_reg = False # unused
is_tty = False
else:
st = os.fstat(fd)
is_fifo = stat.S_ISFIFO(st.st_mode)
##is_reg = stat.S_ISREG(st.st_mode) # unused
is_tty = stat.S_ISCHR(st.st_mode)
if getattr(main_log, 'encoding', None) is None:
main_log = codecs.getwriter("utf-8")(main_log)
if trace_mode is None:
trace_mode = 'TRACE' in flags
if 'D' in flags:
D_mode = True
if upd_mode is None:
if 'UPD' in flags:
upd_mode = True
elif 'NOUPD' in flags:
upd_mode = False
else:
upd_mode = is_tty
if ansi_mode is None:
ansi_mode = is_tty and not env_no_color()
if format is None:
if is_tty or is_fifo:
format = DEFAULT_PFX_FORMAT_TTY
else:
format = DEFAULT_PFX_FORMAT
if 'TDUMP' in flags:
# do a thread dump to the main_log on SIGHUP
# pylint: disable=import-outside-toplevel
import signal
import cs.debug as cs_debug
# pylint: disable=unused-argument
def handler(sig, frame):
cs_debug.thread_dump(None, main_log)
signal.signal(signal.SIGHUP, handler)
upd_ = Upd()
root_logger = logging.getLogger()
if root_logger.handlers:
# The logging system is already set up.
# Just monkey patch the leading handler's formatter.
PfxFormatter.patch_formatter(root_logger.handlers[0].formatter)
else:
# Set up a handler etc.
main_handler = logging.StreamHandler(main_log)
if upd_mode:
main_handler = UpdHandler(main_log,
ansi_mode=ansi_mode,
over_handler=main_handler)
upd_ = main_handler.upd
root_logger.setLevel(level)
if loginfo is None:
# only do this the first time
# TODO: fix this clumsy hack, some kind of stackable state?
main_handler.setFormatter(PfxFormatter(format))
if supplant_root_logger:
root_logger.handlers.pop(0)
root_logger.addHandler(main_handler)
if trace_mode:
# enable tracing in the thread that called setup_logging
Pfx._state.trace = info
trace_level = level
else:
trace_level = logging.DEBUG
if module_names or function_names:
if importlib is None:
warning(
"setup_logging: no importlib (python<2.7?),"
" ignoring module_names=%r/function_names=%r", module_names,
function_names)
else:
for module_name in module_names:
try:
M = importlib.import_module(module_name)
except ImportError:
warning("setup_logging: cannot import %r", module_name)
else:
M.DEBUG = True
for module_name, func_name in function_names:
try:
M = importlib.import_module(module_name)
except ImportError:
warning("setup_logging: cannot import %r", module_name)
continue
F = M
for funcpart in func_name.split('.'):
M = F
try:
F = M.getattr(funcpart)
except AttributeError:
F = None
break
if F is None:
warning("no %s.%s() found", module_name, func_name)
else:
setattr(M, funcpart, _ftrace(F))
loginfo = NS(
logger=root_logger,
level=level,
verbose=verbose,
trace_level=trace_level,
flags=flags,
module_names=module_names,
function_names=function_names,
cmd=cmd_name,
upd=upd_,
upd_mode=upd_mode,
ansi_mode=ansi_mode,
format=format,
)
return loginfo
from types import SimpleNamespace as NS
# Values and expected results as per example in documentation:
# doc/Manuale API REST KalliopePBX V4 per CDR.pdf
credentials = NS(
username="******",
password="******",
domain="default",
salt="b5a8fdcf2f8d5acdad33c4a072a97d7a",
created="2016-04-29T15:48:26Z",
nonce="bfb79078ff44c35714af28b7412a702b",
)
expected = NS(
digest="+PJg7Tb3v98XnL6iJVv+v5hwhYjdzQ2tIWxvJB2cE40=",
digest_pass=("dd7b0be7fa37d6cbaf0b842bf7532f22"
"9cb79ab8d54d509c2aa7eea27a53cd5e"),
xheader_key="X-authenticate",
xheader_value=('RestApiUsernameToken Username="******", Domain="default", '
'Digest="+PJg7Tb3v98XnL6iJVv+v5hwhYjdzQ2tIWxvJB2cE40=", '
'Nonce="bfb79078ff44c35714af28b7412a702b", '
'Created="2016-04-29T15:48:26Z"'),
)
expected.xheader_dict = {expected.xheader_key: expected.xheader_value}
expected.xheader_str = f"{expected.xheader_key}: {expected.xheader_value}"
def infer_logging_level(env_debug=None, environ=None, verbose=None):
''' Infer a logging level from the `env_debug`, which by default
comes from the environment variable `$DEBUG`.
Usually default to `logging.WARNING`, but if `sys.stderr` is a terminal,
default to `logging.INFO`.
Parse the environment variable `$DEBUG` as a comma separated
list of flags.
Examine the in sequence flags to affect the logging level:
* numeric < 1: `logging.WARNING`
* numeric >= 1 and < 2: `logging.INFO`
* numeric >= 2: `logging.DEBUG`
* `"DEBUG"`: `logging.DEBUG`
* `"STATUS"`: `STATUS`
* `"INFO"`: `logging.INFO`
* `"TRACK"`: `TRACK`
* `"WARNING"`: `logging.WARNING`
* `"ERROR"`: `logging.ERROR`
Return an object with the following attributes:
* `.level`: A logging level.
* `.flags`: All the words from `$DEBUG` as separated by commas and uppercased.
* `.module_names`: Module names to be debugged.
* `.function_names`: Functions to be traced in the form *module_name*`.`*func_name*.
'''
if env_debug is None:
if environ is None:
environ = os.environ
env_debug = os.environ.get('DEBUG', '')
level = TRACK
if verbose is None:
if not sys.stderr.isatty():
level = logging.WARNING
elif verbose:
level = logging.VERBOSE
else:
level = logging.WARNING
flags = [F.upper() for F in env_debug.split(',') if len(F)]
module_names = []
function_names = []
for flag in env_debug.split(','):
flag = flag.strip()
if not flag:
continue
if flag.isdigit():
flag_level = int(flag)
if flag_level < 1:
level = logging.WARNING
elif flag_level >= 2:
level = logging.DEBUG
else:
level = logging.INFO
elif flag[0].islower() and is_dotted_identifier(flag):
# modulename
module_names.append(flag)
elif ':' in flag:
# module:funcname
module_name, func_name = flag.split(':', 1)
if is_dotted_identifier(module_name) and is_dotted_identifier(
func_name):
function_names.append((module_name, func_name))
else:
uc_flag = flag.upper()
if uc_flag == 'DEBUG':
level = logging.DEBUG
elif uc_flag == 'STATUS':
level = STATUS
elif uc_flag == 'INFO':
level = logging.INFO
elif uc_flag == 'TRACK':
level = TRACK
# pylint: disable=consider-using-in
elif uc_flag == 'WARN' or uc_flag == 'WARNING':
level = logging.WARNING
elif uc_flag == 'ERROR':
level = logging.ERROR
return NS(level=level,
flags=flags,
module_names=module_names,
function_names=function_names)
