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}'")