async def main():
log_levels = ['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG']
config_template = {
'devices': confuse.Sequence(BluetoothDeviceConfuseTemplate(), ),
'log_level': confuse.Choice(log_levels, default=DEFAULT_LOG_LEVEL),
'mqtt': {
'enabled':
confuse.Choice([True, False], default=DEFAULT_MQTT_ENABLED),
'host':
confuse.String(default=DEFAULT_MQTT_HOST),
'log_level':
confuse.Choice(['ERROR', 'WARNING', 'INFO', 'DEBUG'],
default=DEFAULT_MQTT_LOG_LEVEL),
'port':
confuse.Integer(default=DEFAULT_MQTT_PORT),
'protocol':
confuse.String(default=DEFAULT_MQTT_PROTOCOL),
},
'scheduler': {
'log_level':
confuse.Choice(log_levels, default=DEFAULT_SCHEDULER_LOG_LEVEL),
},
}
config = confuse.Configuration('bluetooth_tracker',
__name__).get(config_template)
kwargs = {}
kwargs['bluetooth_rssi_scanner'] = FakeBluetoothScanner
kwargs['bluetooth_lookup_name_func'] = lambda *_: 'test'
detector = Detector(
config,
mqtt.Client(),
AsyncIOScheduler(),
**kwargs,
)
detector.start_detecting()
killer = GracefulKiller()
while not killer.kill_now:
await asyncio.sleep(1)
logging.info('shutting down')
detector.stop_detecting()
"skip_all_pick_movements": bool,
"wait_at_place_egress": int,
"robot_movement": {
"global_speed_accel": {
"speed_override": float,
"speed_max_tcp": float,
"accel": float,
"accel_ramp": float,
},
"speed": {
"pick": float,
"travel": float,
"place": float,
},
"zone": {
"pick": ZoneDataTemplate(),
"place": ZoneDataTemplate(),
"place_egress": ZoneDataTemplate(),
"travel": ZoneDataTemplate(),
},
"joint_positions": {
"start": confuse.Sequence([float] * 6),
"end": confuse.Sequence([float] * 6),
"travel_trajectory": confuse.TypeTemplate(list, default=None),
},
},
},
}
fab_conf = confuse.LazyConfig("rapid_clay_formations_fab", modname=__name__)
async def main(
config: confuse.Configuration,
*,
input: AsyncIterable[Change],
include_unparsed: bool,
unreleased_version: Optional[str],
) -> jinja2.environment.TemplateStream:
def _is_unreleased(tag: Optional[git.Tag]) -> bool:
return tag is None or tag["name"] == unreleased_version
def _read_config(view: confuse.ConfigView,
default: Any = DEFAULT,
typ: Type = str) -> Any:
try:
return view.get(typ)
except confuse.NotFoundError:
if default is DEFAULT:
raise
return default
excluded = config["tags"]["exclude"].get(confuse.StrSeq(split=False))
try:
tag_filter = config["tags"]["filter"].get(str)
except confuse.NotFoundError:
tag_filter = None
def _ignore_tag(tag: str) -> bool:
if tag_filter and not fnmatch.fnmatch(tag, tag_filter):
return True
if tag in excluded:
return True
return False
versions: List[VersionTuple] = []
version = Version()
async for change in input:
if change["data"] is not None or include_unparsed:
data = change["data"] or {}
typ = data.get("subject", {}).get("type")
if typ not in version:
version[typ] = []
version[typ].append(change)
if change["source"]["tags"]:
tags = [
tag for tag in change["source"]["tags"]
if not _ignore_tag(tag["name"])
]
if tags:
tag = sorted(tags, key=lambda tag: tag["name"])[0]
logger.debug(f"Found new version tag, {tag['name']} "
f"({len(version.get_commits())} commit(s))")
versions.append((tag, version))
version = Version()
if version.has_commits():
logger.debug(
f"Found {len(version.get_commits())} unreleased commit(s)")
unreleased_tag: Optional[git.Tag] = None
if unreleased_version is not None:
logger.debug(
f"Using {unreleased_version} as the version for unreleased commit(s)"
)
unreleased_tag = {
"name": unreleased_version,
"object_name": "",
"subject": "",
"body": "",
}
versions.append((unreleased_tag, version))
logger.debug(f"{len(versions)} versions found")
if not any(version.has_commits() for _, version in versions):
raise exceptions.NoCommitsError()
# Reverse versions list so that it is in reverse chronological order
# (ie. most recent release first)
versions.reverse()
loaders: List[jinja2.BaseLoader] = []
for package in config["template"]["package"].get(
confuse.StrSeq(split=False)):
logger.debug(f"Creating package loader for: {package}")
loaders.append(jinja2.PackageLoader(package))
for directory in config["template"]["directory"].get(
confuse.Sequence(Filename())):
logger.debug(f"Creating file-system loader for: {directory}")
loaders.append(jinja2.FileSystemLoader(directory))
environment = jinja2.Environment(
loader=jinja2.ChoiceLoader(loaders),
extensions=["jinja2.ext.loopcontrols"],
)
environment.filters["read_config"] = _read_config
environment.tests["unreleased"] = _is_unreleased
template = environment.get_template(config["template"]["name"].get(str))
template_config = config["template"]["config"]
return template.stream(versions=versions,
config=template_config,
confuse=confuse)
'name': str,
# The mode in which to run
# 'train': Create a new model
# 'replay': Run an existing model
# 'compete': Run two models against each other
# 'play': Run a model against a human player (controller input)
# 'play-2p': Play traditional human vs human
'mode': confuse.OneOf(['train', 'replay', 'compete', 'play', 'play-2p']),
'input': {
'feature-vector': str,
'controller-discretizer': str,
# The 1+ scenarios that are run in parallel
'scenarios': confuse.Sequence({
# The name of a scenario
'name': str,
# The filename of a scenario (save state) from which to start play
'save-state': str,
# How play in this scenario will be judged
'scorekeeper': str,
}),
# The cost function to use when combining scenarios
'metascorekeeper': str,
# Custom configs that are applied directly to the neat.ini files
'neat-config': dict,
# The checkpoint file to load (relative to yaml file)
'load-checkpoint': [{
'latest': bool,
'specific-filename': [str, None]
}, None],
},
# Information about the movie to record
'movie': {
def test_invalid_item(self):
config = _root({'foo': [{'bar': 1, 'baz': 2}, {'bar': 3, 'bak': 4}]})
with self.assertRaises(confuse.NotFoundError):
config['foo'].get(confuse.Sequence({'bar': int, 'baz': int}))
def test_dict_list(self):
config = _root({'foo': [{'bar': 1, 'baz': 2}, {'bar': 3, 'baz': 4}]})
valid = config['foo'].get(confuse.Sequence({'bar': int, 'baz': int}))
self.assertEqual(valid, [{'bar': 1, 'baz': 2}, {'bar': 3, 'baz': 4}])
def test_int_list(self):
config = _root({'foo': [1, 2, 3]})
valid = config['foo'].get(confuse.Sequence(int))
self.assertEqual(valid, [1, 2, 3])
"tool": {
"tool_name": str,
"io_needles_pin": str,
"grip_state": int,
"release_state": int,
"wait_before_io": confuse.Number(default=2),
"wait_after_io": confuse.Number(default=0.5),
},
"speed_values": {
"speed_override": confuse.Number(default=100),
"speed_max_tcp": float,
"accel": float,
"accel_ramp": confuse.Number(default=100),
},
"safe_joint_positions": {
"start": confuse.Sequence([float] * 6),
"end": confuse.Sequence([float] * 6),
},
"movement": {
"offset_distance": float,
"speed_placing": float,
"speed_picking": float,
"speed_travel": float,
"zone_travel": ZoneDataTemplate(),
"zone_pick": ZoneDataTemplate(),
"zone_place": ZoneDataTemplate(),
},
"pick": {
"origin_grid": {
"x": confuse.Number(default=100),
"y": confuse.Number(default=100),
def test_missing(self):
config = _root({'foo': [1, 2, 3]})
valid = config['bar'].get(confuse.Sequence(int))
self.assertEqual(valid, [])
def test_wrong_type(self):
config = _root({'foo': {'one': 1, 'two': 2, 'three': 3}})
with self.assertRaises(confuse.ConfigTypeError):
config['foo'].get(confuse.Sequence(int))
import re
import confuse
import guessit
from functools import lru_cache
from pathlib import Path
from trakt_scrobbler import config, logger
from trakt_scrobbler.utils import cleanup_encoding
whitelist = config["fileinfo"]["whitelist"].get(
confuse.Sequence(confuse.Path()))
regexes = config["fileinfo"]['include_regexes'].get()
use_regex = any(regexes.values())
def whitelist_file(file_path) -> Path:
if not whitelist:
return True
file_path = cleanup_encoding(file_path)
parents = set(file_path.absolute().resolve().parents)
for path in whitelist:
if path in parents:
return path
return False
def custom_regex(file_path):
path_posix = str(file_path.as_posix())
for item_type, patterns in regexes.items():
for pattern in patterns:
m = re.match(pattern, path_posix)
if m:
from crosscheck.player.rendering import SimpleImageViewer
template = {
# The name of this configuration (for logging purposes)
'name': str,
# The mode in which to run
# 'train': Create a new model
# 'replay': Run an existing model
# 'compete': Run two models against each other
# 'play': Run a model against a human player (controller input)
# 'play-2p': Play traditional human vs human
'mode': confuse.OneOf(['train', 'replay', 'compete', 'play', 'play-2p']),
# The 1+ scenarios that are run in serial
'scenarios': confuse.Sequence({
# The filename of a scenario (save state) from which to start play
'save-state': [str, None],
}),
}
def main(argv):
parser = argparse.ArgumentParser(description='Cross-check: NHL \'94 practice scenarios')
parser.add_argument('config', help='App config.')
args = parser.parse_args(argv)
# Parse the config using confuse, bailing on failure
try:
if args.config:
cc_config.set_file(args.config)
import urllib.parse
import confuse
import git
APP_NAME = 'forksync'
CONFIG_TEMPLATE = {
'ssh_key':
confuse.Filename(),
'cache_dir':
confuse.Filename(default='/cache'),
'log_level':
confuse.String(default='INFO'),
'repositories':
confuse.Sequence({
'origin': confuse.String(),
'upstream': confuse.String()
})
}
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(APP_NAME)
def fix_https_url(url):
scheme, netloc, path, query, fragment = urllib.parse.urlsplit(url)
scheme = 'ssh'
netloc = 'git@' + netloc
if not path:
raise ValueError(
"prometheus": {
"port": confuse.Integer(default=8080),
"metric_name_prefix": confuse.String(default="tungsten"),
},
"scraper": {
"max_retry": confuse.Integer(default=3),
"timeout": confuse.Integer(default=1),
"pool_size": confuse.Integer(default=10),
"interval": confuse.Integer(default=60),
},
"logging": {
"level":
confuse.Choice(choices=["DEBUG", "INFO", "WARNING", "ERROR"],
default="INFO")
},
"metrics": confuse.Sequence(_metric_template),
}
class Config:
instance = None
class __Config:
def __init__(self):
self.config = confuse.LazyConfig("tungsten-prometheus-exporter",
__name__)
def render(self):
try:
self.rendered_config = self.config.get(_global_template)
except confuse.ConfigError as e:
from functools import lru_cache
from typing import Union, List
from urllib.parse import unquote, urlsplit, urlunsplit
import confuse
import guessit
from trakt_scrobbler import config, logger
from trakt_scrobbler.utils import RegexPat, cleanup_encoding, is_url
from urlmatch import BadMatchPattern, urlmatch
cfg = config["fileinfo"]
whitelist = cfg["whitelist"].get(confuse.StrSeq())
regexes: dict = cfg['include_regexes'].get({
"movie":
confuse.Sequence(RegexPat()),
"episode":
confuse.Sequence(RegexPat()),
})
use_regex = any(regexes.values())
exclude_patterns: list = cfg["exclude_patterns"].get(
confuse.Sequence(RegexPat()))
def split_whitelist(whitelist: List[str]):
"""Split whitelist into local and remote urls"""
local, remote = [], []
for path in whitelist:
try:
urlmatch(path,
"<dummy_path>",
path_required=False,
"""An example application using Confuse for configuration."""
from __future__ import division, absolute_import, print_function
import confuse
import argparse
template = {
'library': confuse.Filename(),
'import_write': confuse.OneOf([bool, 'ask', 'skip']),
'ignore': confuse.StrSeq(),
'plugins': list,
'paths': {
'directory': confuse.Filename(),
'default': confuse.Filename(relative_to='directory'),
},
'servers': confuse.Sequence({
'hostname': str,
'options': confuse.StrSeq(),
})
}
config = confuse.LazyConfig('ConfuseExample', __name__)
def main():
parser = argparse.ArgumentParser(description='example Confuse program')
parser.add_argument('--library',
'-l',
dest='library',
metavar='LIBPATH',
help='library database file')
parser.add_argument('--directory',
'-d',
import re
import confuse
import guessit
from functools import lru_cache
from pathlib import Path
from trakt_scrobbler import config, logger
from trakt_scrobbler.utils import cleanup_encoding
whitelist = config["fileinfo"]["whitelist"].get(confuse.Sequence(confuse.Path()))
regexes = config["fileinfo"]['include_regexes'].get()
use_regex = any(regexes.values())
def whitelist_file(file_path) -> Path:
if not whitelist:
return True
file_path = cleanup_encoding(file_path)
parents = set(file_path.absolute().resolve().parents)
for path in whitelist:
if path in parents:
return path
return False
def custom_regex(file_path):
path_posix = str(file_path.as_posix())
for item_type, patterns in regexes.items():
for pattern in patterns:
m = re.match(pattern, path_posix)
if m:
logger.debug(f"Matched regex pattern '{pattern}' for '{path_posix}'")
