Datasets:

Languages: py
Multilinguality: monolingual
Size Categories: 10K<n<100K
Language Creators: found
Annotations Creators: no-annotation
Source Datasets: original
License: unknown
Dataset Preview
Go to dataset viewer
text (string)
" import re import os import sys import time import types import getopt import unittest import traceback try: # Python >=2.7 and >=3.2 from unittest.runner import _TextTestResult except ImportError: from unittest import _TextTestResult __metaclass__ = type def stderr(text): sys.stderr.write(text) sys.stderr.write("\n") class Options: """Configurable properties of the test runner.""" # test location basedir = '' # base directory for tests (defaults to # basedir of argv[0] + 'src'), must be absolute follow_symlinks = True # should symlinks to subdirectories be # followed? (hardcoded, may cause loops) # which tests to run unit_tests = False # unit tests (default if both are false) functional_tests = False # functional tests # test filtering level = 1 # run only tests at this or lower level # (if None, runs all tests) pathname_regex = '' # regexp for filtering filenames test_regex = '' # regexp for filtering test cases # actions to take list_files = False # --list-files list_tests = False # --list-tests list_hooks = False # --list-hooks run_tests = True # run tests (disabled by --list-foo) # output verbosity verbosity = 0 # verbosity level (-v) quiet = 0 # do not print anything on success (-q) warn_omitted = False # produce warnings when a test case is # not included in a test suite (-w) progress = False # show running progress (-p) coverage = False # produce coverage reports (--coverage) coverdir = 'coverage' # where to put them (currently hardcoded) immediate_errors = False # show tracebacks twice (currently hardcoded) screen_width = 80 # screen width (autodetected) def compile_matcher(regex): """Returns a function that takes one argument and returns True or False. Regex is a regular expression. Empty regex matches everything. There is one expression: if the regex starts with "!", the meaning of it is reversed. """ if not regex: return lambda x: True elif regex == '!': return lambda x: False elif regex.startswith('!'): rx = re.compile(regex[1:]) return lambda x: rx.search(x) is None else: rx = re.compile(regex) return lambda x: rx.search(x) is not None def walk_with_symlinks(top, func, arg): """Like os.path.walk, but follows symlinks on POSIX systems. If the symlinks create a loop, this function will never finish. """ try: names = os.listdir(top) except os.error: return func(arg, top, names) exceptions = ('.', '..') for name in names: if name not in exceptions: name = os.path.join(top, name) if os.path.isdir(name): walk_with_symlinks(name, func, arg) def get_test_files(cfg): """Returns a list of test module filenames.""" matcher = compile_matcher(cfg.pathname_regex) results = [] test_names = [] if cfg.unit_tests: test_names.append('tests') if cfg.functional_tests: test_names.append('ftests') baselen = len(cfg.basedir) + 1 def visit(ignored, dir, files): if os.path.basename(dir) not in test_names: for name in test_names: if name + '.py' in files: path = os.path.join(dir, name + '.py') if matcher(path[baselen:]): results.append(path) return if '__init__.py' not in files: stderr("%s is not a package" % dir) return for file in files: if file.startswith('test') and file.endswith('.py'): path = os.path.join(dir, file) if matcher(path[baselen:]): results.append(path) if cfg.follow_symlinks: walker = walk_with_symlinks else: walker = os.path.walk walker(cfg.basedir, visit, None) results.sort() return results def import_module(filename, cfg, cov=None): """Imports and returns a module.""" filename = os.path.splitext(filename)[0] modname = filename[len(cfg.basedir):].replace(os.path.sep, '.') if modname.startswith('.'): modname = modname[1:] if cov is not None: cov.start() mod = __import__(modname) if cov is not None: cov.stop() components = modname.split('.') for comp in components[1:]: mod = getattr(mod, comp) return mod def filter_testsuite(suite, matcher, level=None): """Returns a flattened list of test cases that match the given matcher.""" if not isinstance(suite, unittest.TestSuite): raise TypeError('not a TestSuite', suite) results = [] for test in suite._tests: if level is not None and getattr(test, 'level', 0) > level: continue if isinstance(test, unittest.TestCase): testname = test.id() # package.module.class.method if matcher(testname): results.append(test) else: filtered = filter_testsuite(test, matcher, level) results.extend(filtered) return results def get_all_test_cases(module): """Returns a list of all test case classes defined in a given module.""" results = [] for name in dir(module): if not name.startswith('Test'): continue item = getattr(module, name) if (isinstance(item, (type, types.ClassType)) and issubclass(item, unittest.TestCase)): results.append(item) return results def get_test_classes_from_testsuite(suite): """Returns a set of test case classes used in a test suite.""" if not isinstance(suite, unittest.TestSuite): raise TypeError('not a TestSuite', suite) results = set() for test in suite._tests: if isinstance(test, unittest.TestCase): results.add(test.__class__) else: classes = get_test_classes_from_testsuite(test) results.update(classes) return results def get_test_cases(test_files, cfg, cov=None): """Returns a list of test cases from a given list of test modules.""" matcher = compile_matcher(cfg.test_regex) results = [] for file in test_files: module = import_module(file, cfg, cov=cov) if cov is not None: cov.start() test_suite = module.test_suite() if cov is not None: cov.stop() if test_suite is None: continue if cfg.warn_omitted: all_classes = set(get_all_test_cases(module)) classes_in_suite = get_test_classes_from_testsuite(test_suite) difference = all_classes - classes_in_suite for test_class in difference: # surround the warning with blank lines, otherwise it tends # to get lost in the noise stderr("\n%s: WARNING: %s not in test suite\n" % (file, test_class.__name__)) if (cfg.level is not None and getattr(test_suite, 'level', 0) > cfg.level): continue filtered = filter_testsuite(test_suite, matcher, cfg.level) results.extend(filtered) return results def get_test_hooks(test_files, cfg, cov=None): """Returns a list of test hooks from a given list of test modules.""" results = [] dirs = set(map(os.path.dirname, test_files)) for dir in list(dirs): if os.path.basename(dir) == 'ftests': dirs.add(os.path.join(os.path.dirname(dir), 'tests')) dirs = list(dirs) dirs.sort() for dir in dirs: filename = os.path.join(dir, 'checks.py') if os.path.exists(filename): module = import_module(filename, cfg, tracer=tracer) if cov is not None: cov.start() hooks = module.test_hooks() if cov is not None: cov.stop() results.extend(hooks) return results class CustomTestResult(_TextTestResult): """Customised TestResult. It can show a progress bar, and displays tracebacks for errors and failures as soon as they happen, in addition to listing them all at the end. """ __super = _TextTestResult __super_init = __super.__init__ __super_startTest = __super.startTest __super_stopTest = __super.stopTest __super_printErrors = __super.printErrors def __init__(self, stream, descriptions, verbosity, count, cfg, hooks): self.__super_init(stream, descriptions, verbosity) self.count = count self.cfg = cfg self.hooks = hooks if cfg.progress: self.dots = False self._lastWidth = 0 self._maxWidth = cfg.screen_width - len("xxxx/xxxx (xxx.x%): ") - 1 def startTest(self, test): if self.cfg.progress: # verbosity == 0: 'xxxx/xxxx (xxx.x%)' # verbosity == 1: 'xxxx/xxxx (xxx.x%): test name' # verbosity >= 2: 'xxxx/xxxx (xxx.x%): test name ... ok' n = self.testsRun + 1 self.stream.write("\r%4d" % n) if self.count: self.stream.write("/%d (%5.1f%%)" % (self.count, n * 100.0 / self.count)) if self.showAll: # self.cfg.verbosity == 1 self.stream.write(": ") elif self.cfg.verbosity: name = self.getShortDescription(test) width = len(name) if width < self._lastWidth: name += " " * (self._lastWidth - width) self.stream.write(": %s" % name) self._lastWidth = width self.stream.flush() self.__super_startTest(test) for hook in self.hooks: hook.startTest(test) def stopTest(self, test): for hook in self.hooks: hook.stopTest(test) self.__super_stopTest(test) def getShortDescription(self, test): s = self.getDescription(test) if len(s) > self._maxWidth: # s is 'testname (package.module.class)' # try to shorten it to 'testname (...age.module.class)' # if it is still too long, shorten it to 'testnam...' # limit case is 'testname (...)' pos = s.find(" (") if pos + len(" (...)") > self._maxWidth: s = s[:self._maxWidth - 3] + "..." else: s = "%s...%s" % (s[:pos + 2], s[pos + 5 - self._maxWidth:]) return s def printErrors(self): if self.cfg.progress and not (self.dots or self.showAll): self.stream.writeln() self.__super_printErrors() def formatError(self, err): return "".join(traceback.format_exception(*err)) def printTraceback(self, kind, test, err): self.stream.writeln() self.stream.writeln() self.stream.writeln("%s: %s" % (kind, test)) self.stream.writeln(self.formatError(err)) self.stream.writeln() def addFailure(self, test, err): if self.cfg.immediate_errors: self.printTraceback("FAIL", test, err) self.failures.append((test, self.formatError(err))) def addError(self, test, err): if self.cfg.immediate_errors: self.printTraceback("ERROR", test, err) self.errors.append((test, self.formatError(err))) class CustomTestRunner(unittest.TextTestRunner): """Customised TestRunner. See CustomisedTextResult for a list of extensions. """ __super = unittest.TextTestRunner __super_init = __super.__init__ __super_run = __super.run def __init__(self, cfg, hooks=None): self.__super_init(verbosity=cfg.verbosity) self.cfg = cfg if hooks is not None: self.hooks = hooks else: self.hooks = [] def run(self, test): """Run the given test case or test suite.""" self.count = test.countTestCases() result = self._makeResult() startTime = time.time() test(result) stopTime = time.time() timeTaken = float(stopTime - startTime) result.printErrors() run = result.testsRun if not self.cfg.quiet: self.stream.writeln(result.separator2) self.stream.writeln("Ran %d test%s in %.3fs" % (run, run != 1 and "s" or "", timeTaken)) self.stream.writeln() if not result.wasSuccessful(): self.stream.write("FAILED (") failed, errored = list(map(len, (result.failures, result.errors))) if failed: self.stream.write("failures=%d" % failed) if errored: if failed: self.stream.write(", ") self.stream.write("errors=%d" % errored) self.stream.writeln(")") elif not self.cfg.quiet: self.stream.writeln("OK") return result def _makeResult(self): return CustomTestResult(self.stream, self.descriptions, self.verbosity, cfg=self.cfg, count=self.count, hooks=self.hooks) def main(argv): """Main program.""" # Environment if sys.version_info < (2, 7): stderr('%s: need Python 2.7 or later' % argv[0]) stderr('your python is %s' % sys.version) return 1 # Defaults cfg = Options() cfg.basedir = os.path.join(os.path.dirname(argv[0]), 'src') cfg.basedir = os.path.abspath(cfg.basedir) # Figure out terminal size try: import curses except ImportError: pass else: try: curses.setupterm() cols = curses.tigetnum('cols') if cols > 0: cfg.screen_width = cols except (curses.error, TypeError): # tigetnum() is broken in PyPy3 and raises TypeError pass # Option processing opts, args = getopt.gnu_getopt(argv[1:], 'hvpqufw', ['list-files', 'list-tests', 'list-hooks', 'level=', 'all-levels', 'coverage']) for k, v in opts: if k == '-h': print(__doc__) return 0 elif k == '-v': cfg.verbosity += 1 cfg.quiet = False elif k == '-p': cfg.progress = True cfg.quiet = False elif k == '-q': cfg.verbosity = 0 cfg.progress = False cfg.quiet = True elif k == '-u': cfg.unit_tests = True elif k == '-f': cfg.functional_tests = True elif k == '-w': cfg.warn_omitted = True elif k == '--list-files': cfg.list_files = True cfg.run_tests = False elif k == '--list-tests': cfg.list_tests = True cfg.run_tests = False elif k == '--list-hooks': cfg.list_hooks = True cfg.run_tests = False elif k == '--coverage': cfg.coverage = True elif k == '--level': try: cfg.level = int(v) except ValueError: stderr('%s: invalid level: %s' % (argv[0], v)) stderr('run %s -h for help') return 1 elif k == '--all-levels': cfg.level = None else: stderr('%s: invalid option: %s' % (argv[0], k)) stderr('run %s -h for help') return 1 if args: cfg.pathname_regex = args[0] if len(args) > 1: cfg.test_regex = args[1] if len(args) > 2: stderr('%s: too many arguments: %s' % (argv[0], args[2])) stderr('run %s -h for help') return 1 if not cfg.unit_tests and not cfg.functional_tests: cfg.unit_tests = True # Set up the python path sys.path[0] = cfg.basedir # Set up tracing before we start importing things cov = None if cfg.run_tests and cfg.coverage: from coverage import coverage cov = coverage(omit=['test.py']) # Finding and importing test_files = get_test_files(cfg) if cov is not None: cov.start() if cfg.list_tests or cfg.run_tests: test_cases = get_test_cases(test_files, cfg, cov=cov) if cfg.list_hooks or cfg.run_tests: test_hooks = get_test_hooks(test_files, cfg, cov=cov) # Configure the logging module import logging logging.basicConfig() logging.root.setLevel(logging.CRITICAL) # Running success = True if cfg.list_files: baselen = len(cfg.basedir) + 1 print("\n".join([fn[baselen:] for fn in test_files])) if cfg.list_tests: print("\n".join([test.id() for test in test_cases])) if cfg.list_hooks: print("\n".join([str(hook) for hook in test_hooks])) if cfg.run_tests: runner = CustomTestRunner(cfg, test_hooks) suite = unittest.TestSuite() suite.addTests(test_cases) if cov is not None: cov.start() run_result = runner.run(suite) if cov is not None: cov.stop() success = run_result.wasSuccessful() del run_result if cov is not None: traced_file_types = ('.py', '.pyx', '.pxi', '.pxd') modules = [] def add_file(_, path, files): if 'tests' in os.path.relpath(path, cfg.basedir).split(os.sep): return for filename in files: if filename.endswith(traced_file_types): modules.append(os.path.join(path, filename)) if cfg.follow_symlinks: walker = walk_with_symlinks else: walker = os.path.walk walker(os.path.abspath(cfg.basedir), add_file, None) try: cov.xml_report(modules, outfile='coverage.xml') if cfg.coverdir: cov.html_report(modules, directory=cfg.coverdir) finally: # test runs can take a while, so at least try to print something cov.report() # That's all if success: return 0 else: return 1 if __name__ == '__main__': exitcode = main(sys.argv) sys.exit(exitcode) "
" from homeassistant.components.binary_sensor import ( DOMAIN as BINARY_SENSOR_DOMAIN, BinarySensorEntity, ) from homeassistant.core import callback from homeassistant.util import slugify from . import DOMAIN as MYCHEVY_DOMAIN, UPDATE_TOPIC, EVBinarySensorConfig SENSORS = [EVBinarySensorConfig("Plugged In", "plugged_in", "plug")] async def async_setup_platform(hass, config, async_add_entities, discovery_info=None): """Set up the MyChevy sensors.""" if discovery_info is None: return sensors = [] hub = hass.data[MYCHEVY_DOMAIN] for sconfig in SENSORS: for car in hub.cars: sensors.append(EVBinarySensor(hub, sconfig, car.vid)) async_add_entities(sensors) class EVBinarySensor(BinarySensorEntity): """Base EVSensor class. The only real difference between sensors is which units and what attribute from the car object they are returning. All logic can be built with just setting subclass attributes. """ def __init__(self, connection, config, car_vid): """Initialize sensor with car connection.""" self._conn = connection self._name = config.name self._attr = config.attr self._type = config.device_class self._is_on = None self._car_vid = car_vid self.entity_id = f"{BINARY_SENSOR_DOMAIN}.{MYCHEVY_DOMAIN}_{slugify(self._car.name)}_{slugify(self._name)}" @property def name(self): """Return the name.""" return self._name @property def is_on(self): """Return if on.""" return self._is_on @property def _car(self): """Return the car.""" return self._conn.get_car(self._car_vid) async def async_added_to_hass(self): """Register callbacks.""" self.async_on_remove( self.hass.helpers.dispatcher.async_dispatcher_connect( UPDATE_TOPIC, self.async_update_callback ) ) @callback def async_update_callback(self): """Update state.""" if self._car is not None: self._is_on = getattr(self._car, self._attr, None) self.async_write_ha_state() @property def should_poll(self): """Return the polling state.""" return False "
" import pathlib import re from typing import Dict import voluptuous as vol from voluptuous.humanize import humanize_error from homeassistant.exceptions import HomeAssistantError from homeassistant.helpers import config_validation as cv from homeassistant.util.yaml import load_yaml from .model import Integration def exists(value): """Check if value exists.""" if value is None: raise vol.Invalid("Value cannot be None") return value FIELD_SCHEMA = vol.Schema( { vol.Required("description"): str, vol.Optional("example"): exists, vol.Optional("default"): exists, vol.Optional("values"): exists, vol.Optional("required"): bool, } ) SERVICE_SCHEMA = vol.Schema( { vol.Required("description"): str, vol.Optional("fields"): vol.Schema({str: FIELD_SCHEMA}), } ) SERVICES_SCHEMA = vol.Schema({cv.slug: SERVICE_SCHEMA}) def grep_dir(path: pathlib.Path, glob_pattern: str, search_pattern: str) -> bool: """Recursively go through a dir and it's children and find the regex.""" pattern = re.compile(search_pattern) for fil in path.glob(glob_pattern): if not fil.is_file(): continue if pattern.search(fil.read_text()): return True return False def validate_services(integration: Integration): """Validate services.""" # Find if integration uses services has_services = grep_dir( integration.path, "**/*.py", r"hass\.services\.(register|async_register)" ) if not has_services: return try: data = load_yaml(str(integration.path / "services.yaml")) except FileNotFoundError: integration.add_error("services", "Registers services but has no services.yaml") return except HomeAssistantError: integration.add_error( "services", "Registers services but unable to load services.yaml" ) return try: SERVICES_SCHEMA(data) except vol.Invalid as err: integration.add_error( "services", f"Invalid services.yaml: {humanize_error(data, err)}" ) def validate(integrations: Dict[str, Integration], config): """Handle dependencies for integrations.""" # check services.yaml is cool for integration in integrations.values(): if not integration.manifest: continue validate_services(integration) "
" import asyncio import datetime as dt import os from typing import List from httpx import RequestError import onvif from onvif import ONVIFCamera from onvif.exceptions import ONVIFError from zeep.exceptions import Fault from homeassistant.config_entries import ConfigEntry from homeassistant.const import ( CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT, CONF_USERNAME, ) from homeassistant.core import HomeAssistant import homeassistant.util.dt as dt_util from .const import ( ABSOLUTE_MOVE, CONTINUOUS_MOVE, GOTOPRESET_MOVE, LOGGER, PAN_FACTOR, RELATIVE_MOVE, TILT_FACTOR, ZOOM_FACTOR, ) from .event import EventManager from .models import PTZ, Capabilities, DeviceInfo, Profile, Resolution, Video class ONVIFDevice: """Manages an ONVIF device.""" def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry = None): """Initialize the device.""" self.hass: HomeAssistant = hass self.config_entry: ConfigEntry = config_entry self.available: bool = True self.device: ONVIFCamera = None self.events: EventManager = None self.info: DeviceInfo = DeviceInfo() self.capabilities: Capabilities = Capabilities() self.profiles: List[Profile] = [] self.max_resolution: int = 0 self._dt_diff_seconds: int = 0 @property def name(self) -> str: """Return the name of this device.""" return self.config_entry.data[CONF_NAME] @property def host(self) -> str: """Return the host of this device.""" return self.config_entry.data[CONF_HOST] @property def port(self) -> int: """Return the port of this device.""" return self.config_entry.data[CONF_PORT] @property def username(self) -> int: """Return the username of this device.""" return self.config_entry.data[CONF_USERNAME] @property def password(self) -> int: """Return the password of this device.""" return self.config_entry.data[CONF_PASSWORD] async def async_setup(self) -> bool: """Set up the device.""" self.device = get_device( self.hass, host=self.config_entry.data[CONF_HOST], port=self.config_entry.data[CONF_PORT], username=self.config_entry.data[CONF_USERNAME], password=self.config_entry.data[CONF_PASSWORD], ) # Get all device info try: await self.device.update_xaddrs() await self.async_check_date_and_time() # Create event manager self.events = EventManager( self.hass, self.device, self.config_entry.unique_id ) # Fetch basic device info and capabilities self.info = await self.async_get_device_info() self.capabilities = await self.async_get_capabilities() self.profiles = await self.async_get_profiles() # No camera profiles to add if not self.profiles: return False if self.capabilities.ptz: self.device.create_ptz_service() # Determine max resolution from profiles self.max_resolution = max( profile.video.resolution.width for profile in self.profiles if profile.video.encoding == "H264" ) except RequestError as err: LOGGER.warning( "Couldn't connect to camera '%s', but will retry later. Error: %s", self.name, err, ) self.available = False except Fault as err: LOGGER.error( "Couldn't connect to camera '%s', please verify " "that the credentials are correct. Error: %s", self.name, err, ) return False return True async def async_stop(self, event=None): """Shut it all down.""" if self.events: await self.events.async_stop() await self.device.close() async def async_check_date_and_time(self) -> None: """Warns if device and system date not synced.""" LOGGER.debug("Setting up the ONVIF device management service") device_mgmt = self.device.create_devicemgmt_service() LOGGER.debug("Retrieving current device date/time") try: system_date = dt_util.utcnow() device_time = await device_mgmt.GetSystemDateAndTime() if not device_time: LOGGER.debug( """Couldn't get device '%s' date/time. GetSystemDateAndTime() return null/empty""", self.name, ) return if device_time.UTCDateTime: tzone = dt_util.UTC cdate = device_time.UTCDateTime else: tzone = ( dt_util.get_time_zone(device_time.TimeZone) or dt_util.DEFAULT_TIME_ZONE ) cdate = device_time.LocalDateTime if cdate is None: LOGGER.warning("Could not retrieve date/time on this camera") else: cam_date = dt.datetime( cdate.Date.Year, cdate.Date.Month, cdate.Date.Day, cdate.Time.Hour, cdate.Time.Minute, cdate.Time.Second, 0, tzone, ) cam_date_utc = cam_date.astimezone(dt_util.UTC) LOGGER.debug( "Device date/time: %s | System date/time: %s", cam_date_utc, system_date, ) dt_diff = cam_date - system_date self._dt_diff_seconds = dt_diff.total_seconds() if self._dt_diff_seconds > 5: LOGGER.warning( "The date/time on the device (UTC) is '%s', " "which is different from the system '%s', " "this could lead to authentication issues", cam_date_utc, system_date, ) except RequestError as err: LOGGER.warning( "Couldn't get device '%s' date/time. Error: %s", self.name, err ) async def async_get_device_info(self) -> DeviceInfo: """Obtain information about this device.""" device_mgmt = self.device.create_devicemgmt_service() device_info = await device_mgmt.GetDeviceInformation() # Grab the last MAC address for backwards compatibility mac = None try: network_interfaces = await device_mgmt.GetNetworkInterfaces() for interface in network_interfaces: if interface.Enabled: mac = interface.Info.HwAddress except Fault as fault: if "not implemented" not in fault.message: raise fault LOGGER.debug( "Couldn't get network interfaces from ONVIF device '%s'. Error: %s", self.name, fault, ) return DeviceInfo( device_info.Manufacturer, device_info.Model, device_info.FirmwareVersion, device_info.SerialNumber, mac, ) async def async_get_capabilities(self): """Obtain information about the available services on the device.""" snapshot = False try: media_service = self.device.create_media_service() media_capabilities = await media_service.GetServiceCapabilities() snapshot = media_capabilities and media_capabilities.SnapshotUri except (ONVIFError, Fault, RequestError): pass pullpoint = False try: pullpoint = await self.events.async_start() except (ONVIFError, Fault): pass ptz = False try: self.device.get_definition("ptz") ptz = True except ONVIFError: pass return Capabilities(snapshot, pullpoint, ptz) async def async_get_profiles(self) -> List[Profile]: """Obtain media profiles for this device.""" media_service = self.device.create_media_service() result = await media_service.GetProfiles() profiles = [] if not isinstance(result, list): return profiles for key, onvif_profile in enumerate(result): # Only add H264 profiles if ( not onvif_profile.VideoEncoderConfiguration or onvif_profile.VideoEncoderConfiguration.Encoding != "H264" ): continue profile = Profile( key, onvif_profile.token, onvif_profile.Name, Video( onvif_profile.VideoEncoderConfiguration.Encoding, Resolution( onvif_profile.VideoEncoderConfiguration.Resolution.Width, onvif_profile.VideoEncoderConfiguration.Resolution.Height, ), ), ) # Configure PTZ options if self.capabilities.ptz and onvif_profile.PTZConfiguration: profile.ptz = PTZ( onvif_profile.PTZConfiguration.DefaultContinuousPanTiltVelocitySpace is not None, onvif_profile.PTZConfiguration.DefaultRelativePanTiltTranslationSpace is not None, onvif_profile.PTZConfiguration.DefaultAbsolutePantTiltPositionSpace is not None, ) try: ptz_service = self.device.create_ptz_service() presets = await ptz_service.GetPresets(profile.token) profile.ptz.presets = [preset.token for preset in presets if preset] except (Fault, RequestError): # It's OK if Presets aren't supported profile.ptz.presets = [] profiles.append(profile) return profiles async def async_get_stream_uri(self, profile: Profile) -> str: """Get the stream URI for a specified profile.""" media_service = self.device.create_media_service() req = media_service.create_type("GetStreamUri") req.ProfileToken = profile.token req.StreamSetup = { "Stream": "RTP-Unicast", "Transport": {"Protocol": "RTSP"}, } result = await media_service.GetStreamUri(req) return result.Uri async def async_perform_ptz( self, profile: Profile, distance, speed, move_mode, continuous_duration, preset, pan=None, tilt=None, zoom=None, ): """Perform a PTZ action on the camera.""" if not self.capabilities.ptz: LOGGER.warning("PTZ actions are not supported on device '%s'", self.name) return ptz_service = self.device.create_ptz_service() pan_val = distance * PAN_FACTOR.get(pan, 0) tilt_val = distance * TILT_FACTOR.get(tilt, 0) zoom_val = distance * ZOOM_FACTOR.get(zoom, 0) speed_val = speed preset_val = preset LOGGER.debug( "Calling %s PTZ | Pan = %4.2f | Tilt = %4.2f | Zoom = %4.2f | Speed = %4.2f | Preset = %s", move_mode, pan_val, tilt_val, zoom_val, speed_val, preset_val, ) try: req = ptz_service.create_type(move_mode) req.ProfileToken = profile.token if move_mode == CONTINUOUS_MOVE: # Guard against unsupported operation if not profile.ptz.continuous: LOGGER.warning( "ContinuousMove not supported on device '%s'", self.name ) return req.Velocity = { "PanTilt": {"x": pan_val, "y": tilt_val}, "Zoom": {"x": zoom_val}, } await ptz_service.ContinuousMove(req) await asyncio.sleep(continuous_duration) req = ptz_service.create_type("Stop") req.ProfileToken = profile.token await ptz_service.Stop( {"ProfileToken": req.ProfileToken, "PanTilt": True, "Zoom": False} ) elif move_mode == RELATIVE_MOVE: # Guard against unsupported operation if not profile.ptz.relative: LOGGER.warning( "RelativeMove not supported on device '%s'", self.name ) return req.Translation = { "PanTilt": {"x": pan_val, "y": tilt_val}, "Zoom": {"x": zoom_val}, } req.Speed = { "PanTilt": {"x": speed_val, "y": speed_val}, "Zoom": {"x": speed_val}, } await ptz_service.RelativeMove(req) elif move_mode == ABSOLUTE_MOVE: # Guard against unsupported operation if not profile.ptz.absolute: LOGGER.warning( "AbsoluteMove not supported on device '%s'", self.name ) return req.Position = { "PanTilt": {"x": pan_val, "y": tilt_val}, "Zoom": {"x": zoom_val}, } req.Speed = { "PanTilt": {"x": speed_val, "y": speed_val}, "Zoom": {"x": speed_val}, } await ptz_service.AbsoluteMove(req) elif move_mode == GOTOPRESET_MOVE: # Guard against unsupported operation if preset_val not in profile.ptz.presets: LOGGER.warning( "PTZ preset '%s' does not exist on device '%s'. Available Presets: %s", preset_val, self.name, ", ".join(profile.ptz.presets), ) return req.PresetToken = preset_val req.Speed = { "PanTilt": {"x": speed_val, "y": speed_val}, "Zoom": {"x": speed_val}, } await ptz_service.GotoPreset(req) except ONVIFError as err: if "Bad Request" in err.reason: LOGGER.warning("Device '%s' doesn't support PTZ.", self.name) else: LOGGER.error("Error trying to perform PTZ action: %s", err) def get_device(hass, host, port, username, password) -> ONVIFCamera: """Get ONVIFCamera instance.""" return ONVIFCamera( host, port, username, password, f"{os.path.dirname(onvif.__file__)}/wsdl/", no_cache=True, ) "
" import sys import mne def clean_ecg_eog(in_fif_fname, out_fif_fname=None, eog=True, ecg=True, ecg_proj_fname=None, eog_proj_fname=None, ecg_event_fname=None, eog_event_fname=None, in_path='.', quiet=False): """Clean ECG from raw fif file. Parameters ---------- in_fif_fname : str Raw fif File eog_event_fname : str name of EOG event file required. eog : bool Reject or not EOG artifacts. ecg : bool Reject or not ECG artifacts. ecg_event_fname : str name of ECG event file required. in_path : str Path where all the files are. """ if not eog and not ecg: raise Exception("EOG and ECG cannot be both disabled") # Reading fif File raw_in = mne.io.read_raw_fif(in_fif_fname) if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'): prefix = in_fif_fname[:-8] else: prefix = in_fif_fname[:-4] if out_fif_fname is None: out_fif_fname = prefix + '_clean_ecg_eog_raw.fif' if ecg_proj_fname is None: ecg_proj_fname = prefix + '_ecg-proj.fif' if eog_proj_fname is None: eog_proj_fname = prefix + '_eog-proj.fif' if ecg_event_fname is None: ecg_event_fname = prefix + '_ecg-eve.fif' if eog_event_fname is None: eog_event_fname = prefix + '_eog-eve.fif' print('Implementing ECG and EOG artifact rejection on data') kwargs = dict() if quiet else dict(stdout=None, stderr=None) if ecg: ecg_events, _, _ = mne.preprocessing.find_ecg_events( raw_in, reject_by_annotation=True) print("Writing ECG events in %s" % ecg_event_fname) mne.write_events(ecg_event_fname, ecg_events) print('Computing ECG projector') command = ('mne_process_raw', '--cd', in_path, '--raw', in_fif_fname, '--events', ecg_event_fname, '--makeproj', '--projtmin', '-0.08', '--projtmax', '0.08', '--saveprojtag', '_ecg-proj', '--projnmag', '2', '--projngrad', '1', '--projevent', '999', '--highpass', '5', '--lowpass', '35', '--projmagrej', '4000', '--projgradrej', '3000') mne.utils.run_subprocess(command, **kwargs) if eog: eog_events = mne.preprocessing.find_eog_events(raw_in) print("Writing EOG events in %s" % eog_event_fname) mne.write_events(eog_event_fname, eog_events) print('Computing EOG projector') command = ('mne_process_raw', '--cd', in_path, '--raw', in_fif_fname, '--events', eog_event_fname, '--makeproj', '--projtmin', '-0.15', '--projtmax', '0.15', '--saveprojtag', '_eog-proj', '--projnmag', '2', '--projngrad', '2', '--projevent', '998', '--lowpass', '35', '--projmagrej', '4000', '--projgradrej', '3000') mne.utils.run_subprocess(command, **kwargs) if out_fif_fname is not None: # Applying the ECG EOG projector print('Applying ECG EOG projector') command = ('mne_process_raw', '--cd', in_path, '--raw', in_fif_fname, '--proj', in_fif_fname, '--projoff', '--save', out_fif_fname, '--filteroff', '--proj', ecg_proj_fname, '--proj', eog_proj_fname) mne.utils.run_subprocess(command, **kwargs) print('Done removing artifacts.') print("Cleaned raw data saved in: %s" % out_fif_fname) print('IMPORTANT : Please eye-ball the data !!') else: print('Projection not applied to raw data.') def run(): """Run command.""" from mne.commands.utils import get_optparser parser = get_optparser(__file__) parser.add_option("-i", "--in", dest="raw_in", help="Input raw FIF file", metavar="FILE") parser.add_option("-o", "--out", dest="raw_out", help="Output raw FIF file", metavar="FILE", default=None) parser.add_option("-e", "--no-eog", dest="eog", action="store_false", help="Remove EOG", default=True) parser.add_option("-c", "--no-ecg", dest="ecg", action="store_false", help="Remove ECG", default=True) parser.add_option("-q", "--quiet", dest="quiet", action="store_true", help="Suppress mne_process_raw output", default=False) options, args = parser.parse_args() if options.raw_in is None: parser.print_help() sys.exit(1) raw_in = options.raw_in raw_out = options.raw_out eog = options.eog ecg = options.ecg quiet = options.quiet clean_ecg_eog(raw_in, raw_out, eog=eog, ecg=ecg, quiet=quiet) mne.utils.run_command_if_main() "
" from datetime import timedelta import logging import aiodns from aiodns.error import DNSError import voluptuous as vol from homeassistant.components.sensor import PLATFORM_SCHEMA from homeassistant.const import CONF_NAME import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity import Entity _LOGGER = logging.getLogger(__name__) CONF_HOSTNAME = "hostname" CONF_IPV6 = "ipv6" CONF_RESOLVER = "resolver" CONF_RESOLVER_IPV6 = "resolver_ipv6" DEFAULT_HOSTNAME = "myip.opendns.com" DEFAULT_IPV6 = False DEFAULT_NAME = "myip" DEFAULT_RESOLVER = "208.67.222.222" DEFAULT_RESOLVER_IPV6 = "2620:0:ccc::2" SCAN_INTERVAL = timedelta(seconds=120) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_HOSTNAME, default=DEFAULT_HOSTNAME): cv.string, vol.Optional(CONF_RESOLVER, default=DEFAULT_RESOLVER): cv.string, vol.Optional(CONF_RESOLVER_IPV6, default=DEFAULT_RESOLVER_IPV6): cv.string, vol.Optional(CONF_IPV6, default=DEFAULT_IPV6): cv.boolean, } ) async def async_setup_platform(hass, config, async_add_devices, discovery_info=None): """Set up the DNS IP sensor.""" hostname = config[CONF_HOSTNAME] name = config.get(CONF_NAME) if not name: if hostname == DEFAULT_HOSTNAME: name = DEFAULT_NAME else: name = hostname ipv6 = config[CONF_IPV6] if ipv6: resolver = config[CONF_RESOLVER_IPV6] else: resolver = config[CONF_RESOLVER] async_add_devices([WanIpSensor(hass, name, hostname, resolver, ipv6)], True) class WanIpSensor(Entity): """Implementation of a DNS IP sensor.""" def __init__(self, hass, name, hostname, resolver, ipv6): """Initialize the DNS IP sensor.""" self.hass = hass self._name = name self.hostname = hostname self.resolver = aiodns.DNSResolver() self.resolver.nameservers = [resolver] self.querytype = "AAAA" if ipv6 else "A" self._state = None @property def name(self): """Return the name of the sensor.""" return self._name @property def state(self): """Return the current DNS IP address for hostname.""" return self._state async def async_update(self): """Get the current DNS IP address for hostname.""" try: response = await self.resolver.query(self.hostname, self.querytype) except DNSError as err: _LOGGER.warning("Exception while resolving host: %s", err) response = None if response: self._state = response[0].host else: self._state = None "
" import StringIO import sys import time from nose import tools from docker_registry.core import exceptions import docker_registry.testing as testing from docker_registry.testing import mock_boto # noqa from . import mock_s3 # noqa class StringIOWithError(StringIO.StringIO): '''Throw IOError after reaching EOF.''' def read(self, size): if self.pos == self.len: raise IOError('Reading beyond EOF') return StringIO.StringIO.read(self, size) class TestDriver(testing.Driver): '''Extra tests for coverage completion.''' def __init__(self): self.scheme = 's3' self.path = '' self.config = testing.Config({}) def tearDown(self): self._storage._boto_bucket.delete() super(TestDriver, self).tearDown() @tools.raises(exceptions.FileNotFoundError) def test_list_bucket(self): # Add a couple of bucket keys filename1 = self.gen_random_string() filename2 = self.gen_random_string() content = self.gen_random_string() self._storage.put_content(filename1, content) # Check bucket key is stored in normalized form self._storage.put_content(filename2 + '/', content) # Check both keys are in the bucket assert sorted([filename1, filename2]) == sorted( list(self._storage.list_directory())) # Check listing bucket raises exception after removing keys self._storage.remove(filename1) self._storage.remove(filename2) s = self._storage.list_directory() s.next() def test_stream_write(self): # Check stream write with buffer bigger than default 5MB self._storage.buffer_size = 7 * 1024 * 1024 filename = self.gen_random_string() # Test 8MB content = self.gen_random_string(8 * 1024 * 1024) io = StringIOWithError(content) assert not self._storage.exists(filename) try: self._storage.stream_write(filename, io) except IOError: pass assert self._storage.exists(filename) # Test that EOFed io string throws IOError on lib/storage/s3 try: self._storage.stream_write(filename, io) except IOError: pass # Cleanup io.close() self._storage.remove(filename) self._storage.buffer_size = 5 * 1024 * 1024 assert not self._storage.exists(filename) def test_init_path(self): # s3 storage _init_path result keys are relative (no / at start) root_path = self._storage._root_path if root_path.startswith('/'): self._storage._root_path = root_path[1:] assert not self._storage._init_path().startswith('/') self._storage._root_path = root_path def test_debug_key(self): # Create a valid s3 key object to debug filename = self.gen_random_string() content = self.gen_random_string() self._storage.put_content(filename, content) # Get filename key path as stored key_path = self._storage._init_path(filename) key = self._storage._boto_bucket.lookup(key_path) self._storage._debug_key(key) # Capture debugged output saved_stdout = sys.stdout output = StringIO.StringIO() sys.stdout = output # As key is mocked for unittest purposes, we call make_request directly dummy = "################\n('d', 1)\n{'v': 2}\n################\n" # '{}\n{}\n{}\n{}\n'.format( # '#' * 16, ('d', 1), {'v': 2}, '#' * 16) result = self._storage._boto_bucket.connection.make_request( 'd', 1, v=2) assert output.getvalue() == dummy assert result == 'request result' sys.stdout = saved_stdout # We don't call self._storage.remove(filename) here to ensure tearDown # cleanup properly and that other tests keep running as expected. # Validation test for docker-index#486 def test_get_tags(self): store = self._storage store._root_path = 'my/custom/path' store._init_path() assert store._root_path == 'my/custom/path' tag_path = store.tag_path('test', 'test', '0.0.2') store.put_content(tag_path, 'randomdata') tags_path = store.tag_path('test', 'test') for fname in store.list_directory(tags_path): full_tag_name = fname.split('/').pop() if not full_tag_name == 'tag_0.0.2': continue try: store.get_content(fname) except exceptions.FileNotFoundError: pass except Exception as e: raise e else: assert False tag_content = store.get_content(tag_path) assert tag_content == 'randomdata' def test_consistency_latency(self): self.testCount = -1 mockKey = mock_boto.Key() def mockExists(): self.testCount += 1 return self.testCount == 1 mockKey.exists = mockExists mockKey.get_contents_as_string = lambda: "Foo bar" self._storage.makeKey = lambda x: mockKey startTime = time.time() content = self._storage.get_content("/FOO") waitTime = time.time() - startTime assert waitTime >= 0.1, ("Waiting time was less than %sms " "(actual : %sms)" % (0.1 * 1000, waitTime * 1000)) assert content == "Foo bar", ("expected : %s; actual: %s" % ("Foo bar", content)) @tools.raises(exceptions.FileNotFoundError) def test_too_many_read_retries(self): self.testCount = -1 mockKey = mock_boto.Key() def mockExists(): self.testCount += 1 return self.testCount == 5 mockKey.exists = mockExists mockKey.get_contents_as_string = lambda: "Foo bar" self._storage.makeKey = lambda x: mockKey self._storage.get_content("/FOO") "
" import unittest from absl import flags import mock from perfkitbenchmarker import benchmark_sets from perfkitbenchmarker import configs from perfkitbenchmarker import linux_benchmarks # This import to ensure required FLAGS are defined. from perfkitbenchmarker import pkb # NOQA import six import yaml FLAGS = flags.FLAGS FLAGS.mark_as_parsed() USER_CONFIG = """ internal_iprf: name: iperf flags: ip_addresses: INTERNAL """ MATRIX_CONFIG = """ netperf: flag_matrix: GCP flag_matrix_defs: GCP: machine_type: [n1-standard-1, n1-standard-4] zones: [us-central1-a, us-central1-b] """ EXPECTED_MATRIX_FLAGS = [ {'machine_type': 'n1-standard-1', 'zones': 'us-central1-a'}, {'machine_type': 'n1-standard-1', 'zones': 'us-central1-b'}, {'machine_type': 'n1-standard-4', 'zones': 'us-central1-a'}, {'machine_type': 'n1-standard-4', 'zones': 'us-central1-b'} ] ZIP_CONFIG_DIFFERENT_AXES_LENGTH = """ netperf: flags: gpu_type: k80 flag_zip: GCP flag_zip_defs: GCP: machine_type: [n1-standard-4, n1-standard-8] gpu_count: [1, 2, 3] """ ZIP_CONFIG = """ netperf: flags: gpu_type: k80 flag_zip: GCP flag_zip_defs: GCP: machine_type: [n1-standard-4, n1-standard-8] gpu_count: [1, 2] """ EXPECTED_ZIP_FLAGS = [ {'machine_type': 'n1-standard-4', 'gpu_count': 1, 'gpu_type': 'k80'}, {'machine_type': 'n1-standard-8', 'gpu_count': 2, 'gpu_type': 'k80'} ] SINGLE_ZIP_CONFIG = """ netperf: flags: gpu_type: k80 flag_zip: GCP flag_zip_defs: GCP: machine_type: [n1-standard-4, n1-standard-8] """ EXPECTED_SINGLE_ZIP_FLAGS = [ {'machine_type': 'n1-standard-4', 'gpu_type': 'k80'}, {'machine_type': 'n1-standard-8', 'gpu_type': 'k80'} ] ZIP_AND_MATRIX_CONFIG = """ netperf: flags: gpu_type: k80 flag_zip: GCP flag_matrix: GCP flag_zip_defs: GCP: machine_type: [n1-standard-4, n1-standard-8] gpu_count: [1, 2] flag_matrix_defs: GCP: zones: [us-central1-a, us-central1-b] """ EXPECTED_ZIP_AND_MATRIX_FLAGS = [ {'zones': 'us-central1-a', 'gpu_type': 'k80', 'machine_type': 'n1-standard-4', 'gpu_count': 1}, {'zones': 'us-central1-b', 'gpu_type': 'k80', 'machine_type': 'n1-standard-4', 'gpu_count': 1}, {'zones': 'us-central1-b', 'gpu_type': 'k80', 'machine_type': 'n1-standard-8', 'gpu_count': 2}, {'zones': 'us-central1-a', 'gpu_type': 'k80', 'machine_type': 'n1-standard-8', 'gpu_count': 2} ] FILTER_CONFIG = """ netperf: flag_matrix: GCP flag_matrix_filters: GCP: "machine_type == 'n1-standard-1' and zones == 'us-central1-a'" flag_matrix_defs: GCP: machine_type: [n1-standard-1, n1-standard-4] zones: [us-central1-a, us-central1-b] """ FLAG_PRECEDENCE_CONFIG = """ flags: netperf_benchmarks: TCP_RR netperf_test_length: 30 netperf_max_iter: 3 netperf: flags: netperf_benchmarks: UDP_RR netperf_test_length: 40 flag_matrix: test_matrix flag_matrix_defs: test_matrix: netperf_benchmarks: [TCP_STREAM] """ class BenchmarkSetsTestCase(unittest.TestCase): def setUp(self): # create set of valid benchmark names from the benchmark directory self.valid_benchmark_names = set() for benchmark_module in linux_benchmarks.BENCHMARKS: self.valid_benchmark_names.add(benchmark_module.BENCHMARK_NAME) self.valid_benchmark_set_names = set() # include the benchmark_set names since these can also appear # as a valid name. At runtime they get expanded. for benchmark_set_name in benchmark_sets.BENCHMARK_SETS: self.valid_benchmark_set_names.add(benchmark_set_name) # Mock flags to simulate setting --benchmarks. p = mock.patch(benchmark_sets.__name__ + '.FLAGS') self.mock_flags = p.start() self.addCleanup(p.stop) self.addCleanup(configs.GetConfigFlags.cache_clear) self.mock_flags.flag_matrix = None self.mock_flags.flag_zip = None self.mock_flags.num_benchmark_copies = 1 def testStandardSet(self): self.assertIn(benchmark_sets.STANDARD_SET, benchmark_sets.BENCHMARK_SETS) standard_set = (benchmark_sets.BENCHMARK_SETS[ benchmark_sets.STANDARD_SET])[benchmark_sets.BENCHMARK_LIST] self.assertIn('iperf', standard_set) self.assertIn('fio', standard_set) def testBenchmarkSetsHaveValidNames(self): # check all the benchmark sets to make sure they contain valid names valid_benchmark_and_set_names = (self.valid_benchmark_names | self.valid_benchmark_set_names) benchmark_set_items = list(benchmark_sets.BENCHMARK_SETS.items()) for _, key_value in benchmark_set_items: benchmark_def_list = key_value[benchmark_sets.BENCHMARK_LIST] for benchmark_name in benchmark_def_list: self.assertIn(benchmark_name, valid_benchmark_and_set_names) def testBenchmarkDerivedSets(self): # make sure that sets which are derived from the standard_set # expands into a valid set of benchmarks with mock.patch.dict( benchmark_sets.BENCHMARK_SETS, { 'test_derived_set': { benchmark_sets.MESSAGE: 'test derived benchmark set.', benchmark_sets.BENCHMARK_LIST: [benchmark_sets.STANDARD_SET] } }): self.mock_flags.benchmarks = ['test_derived_set'] benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertIsNotNone(benchmark_tuple_list) self.assertGreater(len(benchmark_tuple_list), 0) for benchmark_tuple in benchmark_tuple_list: self.assertIn(benchmark_tuple[0].BENCHMARK_NAME, self.valid_benchmark_names) def testBenchmarkNestedDerivedSets(self): # make sure that sets which are derived from the standard_set # expands into a valid set of benchmarks self.mock_flags.benchmarks = [benchmark_sets.STANDARD_SET] standard_module_list = benchmark_sets.GetBenchmarksFromFlags() with mock.patch.dict( benchmark_sets.BENCHMARK_SETS, { 'test_derived_set': { benchmark_sets.MESSAGE: 'test derived benchmark set.', benchmark_sets.BENCHMARK_LIST: [benchmark_sets.STANDARD_SET] }, 'test_nested_derived_set': { benchmark_sets.MESSAGE: 'test nested derived benchmark set.', benchmark_sets.BENCHMARK_LIST: ['test_derived_set'] } }): # TODO(voellm): better check would be to make sure both lists are the same benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertIsNotNone(benchmark_tuple_list) self.assertIsNotNone(standard_module_list) self.assertEqual(len(benchmark_tuple_list), len(standard_module_list)) for benchmark_tuple in benchmark_tuple_list: self.assertIn(benchmark_tuple[0].BENCHMARK_NAME, self.valid_benchmark_names) def testBenchmarkValidCommandLine1(self): # make sure the standard_set expands to a valid set of benchmarks self.mock_flags.benchmarks = ['standard_set'] benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertIsNotNone(benchmark_tuple_list) self.assertGreater(len(benchmark_tuple_list), 0) for benchmark_tuple in benchmark_tuple_list: self.assertIn(benchmark_tuple[0].BENCHMARK_NAME, self.valid_benchmark_names) @staticmethod def _ContainsModule(module_name, module_list): for module_tuple in module_list: if module_tuple[0].BENCHMARK_NAME == module_name: return True return False def testBenchmarkValidCommandLine2(self): # make sure the standard_set plus a listed benchmark expands # to a valid set of benchmarks self.mock_flags.benchmarks = ['standard_set', 'bonnieplusplus'] benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertIsNotNone(benchmark_tuple_list) self.assertGreater(len(benchmark_tuple_list), 0) for benchmark_tuple in benchmark_tuple_list: self.assertIn(benchmark_tuple[0].BENCHMARK_NAME, self.valid_benchmark_names) # make sure bonnieplusplus is a listed benchmark self.assertTrue(self._ContainsModule('bonnieplusplus', benchmark_tuple_list)) def testBenchmarkValidCommandLine3(self): # make sure the command with two benchmarks is processed correctly self.mock_flags.benchmarks = ['iperf', 'fio'] benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertIsNotNone(benchmark_tuple_list) self.assertEqual(len(benchmark_tuple_list), 2) for benchmark_tuple in benchmark_tuple_list: self.assertIn(benchmark_tuple[0].BENCHMARK_NAME, self.valid_benchmark_names) # make sure listed benchmarks are present self.assertTrue(self._ContainsModule('iperf', benchmark_tuple_list)) self.assertTrue(self._ContainsModule('fio', benchmark_tuple_list)) def testBenchmarkInvalidCommandLine1(self): # make sure invalid benchmark names and sets cause a failure self.mock_flags.benchmarks = ['standard_set_invalid_name'] self.assertRaises(ValueError, benchmark_sets.GetBenchmarksFromFlags) def testBenchmarkInvalidCommandLine2(self): # make sure invalid benchmark names and sets cause a failure self.mock_flags.benchmarks = ['standard_set', 'iperf_invalid_name'] self.assertRaises(ValueError, benchmark_sets.GetBenchmarksFromFlags) def testConfigNames(self): self.mock_flags.benchmarks = ['internal_iprf', 'netperf'] with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(USER_CONFIG)): benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertTrue(self._ContainsModule('iperf', benchmark_tuple_list)) self.assertTrue(self._ContainsModule('netperf', benchmark_tuple_list)) def testMatrices(self): self.mock_flags.benchmarks = ['netperf'] with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(MATRIX_CONFIG)): benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertEqual(len(benchmark_tuple_list), 4) flag_list = [benchmark_tuple[1]['flags'] for benchmark_tuple in benchmark_tuple_list] six.assertCountEqual(self, flag_list, EXPECTED_MATRIX_FLAGS) def testZipWithDifferentAxesLengths(self): self.mock_flags.benchmarks = ['netperf'] with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(ZIP_CONFIG_DIFFERENT_AXES_LENGTH)): self.assertRaises(ValueError, benchmark_sets.GetBenchmarksFromFlags) def testZip(self): self.mock_flags.benchmarks = ['netperf'] with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(ZIP_CONFIG)): benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertEqual(len(benchmark_tuple_list), 2) flag_list = [benchmark_tuple[1]['flags'] for benchmark_tuple in benchmark_tuple_list] six.assertCountEqual(self, flag_list, EXPECTED_ZIP_FLAGS) def testZipSingleAxis(self): self.mock_flags.benchmarks = ['netperf'] with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(SINGLE_ZIP_CONFIG)): benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertEqual(len(benchmark_tuple_list), 2) flag_list = [benchmark_tuple[1]['flags'] for benchmark_tuple in benchmark_tuple_list] six.assertCountEqual(self, flag_list, EXPECTED_SINGLE_ZIP_FLAGS) def testZipAndMatrix(self): self.mock_flags.benchmarks = ['netperf'] with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(ZIP_AND_MATRIX_CONFIG)): benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertEqual(len(benchmark_tuple_list), 4) flag_list = [benchmark_tuple[1]['flags'] for benchmark_tuple in benchmark_tuple_list] six.assertCountEqual(self, flag_list, EXPECTED_ZIP_AND_MATRIX_FLAGS) def testFilters(self): self.mock_flags.benchmarks = ['netperf'] with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(FILTER_CONFIG)): benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertEqual(len(benchmark_tuple_list), 1) self.assertEqual(benchmark_tuple_list[0][1]['flags'], {'zones': 'us-central1-a', 'machine_type': 'n1-standard-1'}) def testFlagPrecedence(self): self.mock_flags.benchmarks = ['netperf'] with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(FLAG_PRECEDENCE_CONFIG)): benchmark_tuple_list = benchmark_sets.GetBenchmarksFromFlags() self.assertEqual(len(benchmark_tuple_list), 1) self.assertEqual(benchmark_tuple_list[0][1]['flags'], {'netperf_benchmarks': 'TCP_STREAM', 'netperf_test_length': 40, 'netperf_max_iter': 3}) def testFlagMatrixNotFound(self): self.mock_flags.benchmarks = ['netperf'] self.mock_flags.flag_matrix = 'bad_flag_matrix_name' with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(USER_CONFIG)): with self.assertRaises(benchmark_sets.FlagMatrixNotFoundException): benchmark_sets.GetBenchmarksFromFlags() def testFlagZipNotFound(self): self.mock_flags.benchmarks = ['netperf'] self.mock_flags.flag_zip = 'bad_flag_zip_name' with mock.patch( 'perfkitbenchmarker.configs.GetUserConfig', return_value=yaml.safe_load(USER_CONFIG)): with self.assertRaises(benchmark_sets.FlagZipNotFoundException): benchmark_sets.GetBenchmarksFromFlags() if __name__ == '__main__': unittest.main() "
" from absl import flags from perfkitbenchmarker.linux_packages import nvidia_driver FLAGS = flags.FLAGS flags.DEFINE_string('torch_version', '1.7.1', 'The torch version.') flags.DEFINE_string('torchvision_version', '0.8.2', 'The torchvision version.') flags.DEFINE_string('torchaudio_version', '0.7.2', 'The torchaudio version.') flags.DEFINE_string('torch_env', 'PATH=/opt/conda/bin:$PATH', 'The torch install environment.') _PYTORCH_WHL = 'https://download.pytorch.org/whl/torch_stable.html' def Install(vm): """Installs PyTorch on the VM.""" vm.InstallPackages('python3-pip') toolkit = 'cpu' if nvidia_driver.CheckNvidiaGpuExists(vm): # Translates --cuda_toolkit_version=10.2 to "cu102" for the toolkit to # install toolkit = f'cu{"".join(FLAGS.cuda_toolkit_version.split("."))}' vm.RemoteCommand( f'{FLAGS.torch_env} python3 -m pip install ' f'torch=={FLAGS.torch_version}+{toolkit} ' f'torchvision=={FLAGS.torchvision_version}+{toolkit} ' f'torchaudio=={FLAGS.torchaudio_version} ' f'-f {_PYTORCH_WHL}') def Uninstall(vm): """Uninstalls TensorFlow on the VM.""" vm.RemoteCommand(f'{FLAGS.torch_env} pip uninstall ' 'torch torchvision torchaudio') "
" import os import testinfra.utils.ansible_runner testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner( os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all') # EC2 provides unique random hostnames. def test_hostname(host): pass def test_etc_molecule_directory(host): f = host.file('/etc/molecule') assert f.is_directory assert f.user == 'root' assert f.group == 'root' assert f.mode == 0o755 def test_etc_molecule_ansible_hostname_file(host): filename = '/etc/molecule/{}'.format(host.check_output('hostname -s')) f = host.file(filename) assert f.is_file assert f.user == 'root' assert f.group == 'root' assert f.mode == 0o644 "
" import re import os.path import functools from PyQt5.QtCore import pyqtSlot, Qt, QUrl, QObject from PyQt5.QtWebEngineWidgets import QWebEngineDownloadItem from qutebrowser.browser import downloads, pdfjs from qutebrowser.utils import debug, usertypes, message, log, objreg class DownloadItem(downloads.AbstractDownloadItem): """A wrapper over a QWebEngineDownloadItem. Attributes: _qt_item: The wrapped item. """ def __init__(self, qt_item: QWebEngineDownloadItem, manager: downloads.AbstractDownloadManager, parent: QObject = None) -> None: super().__init__(manager=manager, parent=manager) self._qt_item = qt_item qt_item.downloadProgress.connect( # type: ignore[attr-defined] self.stats.on_download_progress) qt_item.stateChanged.connect( # type: ignore[attr-defined] self._on_state_changed) # Ensure wrapped qt_item is deleted manually when the wrapper object # is deleted. See https://github.com/qutebrowser/qutebrowser/issues/3373 self.destroyed.connect(self._qt_item.deleteLater) def _is_page_download(self): """Check if this item is a page (i.e. mhtml) download.""" return (self._qt_item.savePageFormat() != QWebEngineDownloadItem.UnknownSaveFormat) @pyqtSlot(QWebEngineDownloadItem.DownloadState) def _on_state_changed(self, state): state_name = debug.qenum_key(QWebEngineDownloadItem, state) log.downloads.debug("State for {!r} changed to {}".format( self, state_name)) if state == QWebEngineDownloadItem.DownloadRequested: pass elif state == QWebEngineDownloadItem.DownloadInProgress: pass elif state == QWebEngineDownloadItem.DownloadCompleted: log.downloads.debug("Download {} finished".format(self.basename)) if self._is_page_download(): # Same logging as QtWebKit mhtml downloads. log.downloads.debug("File successfully written.") self.successful = True self.done = True self.finished.emit() self.stats.finish() elif state == QWebEngineDownloadItem.DownloadCancelled: self.successful = False self.done = True self.cancelled.emit() self.stats.finish() elif state == QWebEngineDownloadItem.DownloadInterrupted: self.successful = False reason = self._qt_item.interruptReasonString() self._die(reason) else: raise ValueError("_on_state_changed was called with unknown state " "{}".format(state_name)) def _do_die(self): progress_signal = self._qt_item.downloadProgress progress_signal.disconnect() # type: ignore[attr-defined] if self._qt_item.state() != QWebEngineDownloadItem.DownloadInterrupted: self._qt_item.cancel() def _do_cancel(self): state = self._qt_item.state() state_name = debug.qenum_key(QWebEngineDownloadItem, state) assert state not in [QWebEngineDownloadItem.DownloadCompleted, QWebEngineDownloadItem.DownloadCancelled], state_name self._qt_item.cancel() def retry(self): state = self._qt_item.state() if state != QWebEngineDownloadItem.DownloadInterrupted: log.downloads.warning( "Refusing to retry download in state {}".format( debug.qenum_key(QWebEngineDownloadItem, state))) return self._qt_item.resume() def _get_open_filename(self): return self._filename def url(self) -> QUrl: return self._qt_item.url() def _set_fileobj(self, fileobj, *, autoclose=True): raise downloads.UnsupportedOperationError def _set_tempfile(self, fileobj): fileobj.close() self._set_filename(fileobj.name, force_overwrite=True, remember_directory=False) def _ensure_can_set_filename(self, filename): state = self._qt_item.state() if state != QWebEngineDownloadItem.DownloadRequested: state_name = debug.qenum_key(QWebEngineDownloadItem, state) raise ValueError("Trying to set filename {} on {!r} which is " "state {} (not in requested state)!".format( filename, self, state_name)) def _ask_confirm_question(self, title, msg, *, custom_yes_action=None): yes_action = custom_yes_action or self._after_set_filename no_action = functools.partial(self.cancel, remove_data=False) question = usertypes.Question() question.title = title question.text = msg question.url = 'file://{}'.format(self._filename) question.mode = usertypes.PromptMode.yesno question.answered_yes.connect(yes_action) question.answered_no.connect(no_action) question.cancelled.connect(no_action) self.cancelled.connect(question.abort) self.error.connect(question.abort) message.global_bridge.ask(question, blocking=True) def _ask_create_parent_question(self, title, msg, force_overwrite, remember_directory): assert self._filename is not None no_action = functools.partial(self.cancel, remove_data=False) question = usertypes.Question() question.title = title question.text = msg question.url = 'file://{}'.format(os.path.dirname(self._filename)) question.mode = usertypes.PromptMode.yesno question.answered_yes.connect(lambda: self._after_create_parent_question( force_overwrite, remember_directory)) question.answered_no.connect(no_action) question.cancelled.connect(no_action) self.cancelled.connect(question.abort) self.error.connect(question.abort) message.global_bridge.ask(question, blocking=True) def _after_set_filename(self): assert self._filename is not None dirname, basename = os.path.split(self._filename) try: # Qt 5.14 self._qt_item.setDownloadDirectory(dirname) self._qt_item.setDownloadFileName(basename) except AttributeError: self._qt_item.setPath(self._filename) self._qt_item.accept() def _get_conflicting_download(self): """Return another potential active download with the same name. webenginedownloads.DownloadItem needs to look for downloads both in its manager and in qtnetwork-download-manager as both are used simultaneously. This method can be safely removed once #2328 is fixed. """ conflicting_download = super()._get_conflicting_download() if conflicting_download: return conflicting_download qtnetwork_download_manager = objreg.get( 'qtnetwork-download-manager') for download in qtnetwork_download_manager.downloads: if self._conflicts_with(download): return download return None def _get_suggested_filename(path): """Convert a path we got from chromium to a suggested filename. Chromium thinks we want to download stuff to ~/Download, so even if we don't, we get downloads with a suffix like (1) for files existing there. We simply strip the suffix off via regex. See https://bugreports.qt.io/browse/QTBUG-56978 """ filename = os.path.basename(path) suffix_re = re.compile(r""" \ ? # Optional space between filename and suffix ( # Numerical suffix \([0-9]+\) | # ISO-8601 suffix # https://cs.chromium.org/chromium/src/base/time/time_to_iso8601.cc \ -\ \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z ) (?=\.|$) # Begin of extension, or filename without extension """, re.VERBOSE) return suffix_re.sub('', filename) class DownloadManager(downloads.AbstractDownloadManager): """Manager for currently running downloads. Attributes: _mhtml_target: DownloadTarget for the next MHTML download. """ def __init__(self, parent=None): super().__init__(parent) self._mhtml_target = None def install(self, profile): """Set up the download manager on a QWebEngineProfile.""" profile.downloadRequested.connect(self.handle_download, Qt.DirectConnection) @pyqtSlot(QWebEngineDownloadItem) def handle_download(self, qt_item): """Start a download coming from a QWebEngineProfile.""" suggested_filename = _get_suggested_filename(qt_item.path()) use_pdfjs = pdfjs.should_use_pdfjs(qt_item.mimeType(), qt_item.url()) download = DownloadItem(qt_item, manager=self) self._init_item(download, auto_remove=use_pdfjs, suggested_filename=suggested_filename) if self._mhtml_target is not None: download.set_target(self._mhtml_target) self._mhtml_target = None return if use_pdfjs: download.set_target(downloads.PDFJSDownloadTarget()) return filename = downloads.immediate_download_path() if filename is not None: # User doesn't want to be asked, so just use the download_dir target = downloads.FileDownloadTarget(filename) download.set_target(target) return # Ask the user for a filename - needs to be blocking! question = downloads.get_filename_question( suggested_filename=suggested_filename, url=qt_item.url(), parent=self) self._init_filename_question(question, download) message.global_bridge.ask(question, blocking=True) # The filename is set via the question.answered signal, connected in # _init_filename_question. def get_mhtml(self, tab, target): """Download the given tab as mhtml to the given target.""" assert tab.backend == usertypes.Backend.QtWebEngine assert self._mhtml_target is None, self._mhtml_target self._mhtml_target = target tab.action.save_page() "
" from unittest import TestCase import numpy as np import pandas as pd from scattertext import whitespace_nlp from scattertext.TermDocMatrixFromPandas import TermDocMatrixWithoutCategoriesFromPandas, TermDocMatrixFromPandas from scattertext.TermDocMatrixWithoutCategories import TermDocMatrixWithoutCategories from scattertext.test.test_corpusFromPandas import get_docs_categories class CorpusFromPandasWithoutCategories(): pass def get_term_doc_matrix_without_categories(): categories, documents = get_docs_categories() df = pd.DataFrame({'text': documents}) tdm = TermDocMatrixWithoutCategoriesFromPandas(df, 'text', nlp=whitespace_nlp).build() return tdm class TestCorpusFromPandasWithoutCategories(TestCase): def test_term_category_matrix_from_pandas_without_categories(self): tdm = get_term_doc_matrix_without_categories() categories, documents = get_docs_categories() reg_tdm = TermDocMatrixFromPandas(pd.DataFrame({'text': documents, 'categories': categories}), text_col='text', category_col='categories', nlp=whitespace_nlp).build() self.assertIsInstance(tdm, TermDocMatrixWithoutCategories) self.assertEqual(tdm.get_terms(), reg_tdm.get_terms()) self.assertEqual(tdm.get_num_docs(), reg_tdm.get_num_docs()) np.testing.assert_equal(tdm.get_term_doc_mat().data, reg_tdm.get_term_doc_mat().data) "
" from ...utils import verbose from ..utils import _data_path, _data_path_doc @verbose def data_path(path=None, force_update=False, update_path=True, download=True, verbose=None): # noqa: D103 return _data_path(path=path, force_update=force_update, update_path=update_path, name='misc', download=download) data_path.__doc__ = _data_path_doc.format(name='misc', conf='MNE_DATASETS_MISC_PATH') "
" import threading import imp import os from stash.system import shthreads def get_stash(): """ returns the currently active StaSh-instance. returns None if it can not be found. This is useful for modules. """ if "_stash" in globals(): return globals()["_stash"] for thr in threading.enumerate(): if isinstance(thr, shthreads.ShBaseThread): ct = thr while not ct.is_top_level(): ct = ct.parent return ct.parent.stash return None def load_from_dir(dirpath, varname): """ returns a list of all variables named 'varname' in .py files in a directofy 'dirname'. """ if not os.path.isdir(dirpath): return [] ret = [] for fn in os.listdir(dirpath): fp = os.path.join(dirpath, fn) if not os.path.isfile(fp): continue with open(fp, "r") as fin: mod = imp.load_source(fn[:fn.index(".")], fp, fin) if not hasattr(mod, varname): continue else: ret.append(getattr(mod, varname)) return ret "
" import numpy as np import warnings import chainer from chainer.backends import cuda from chainercv.transforms import center_crop from chainercv.transforms import resize from chainercv.transforms import scale from chainercv.transforms import ten_crop class FeaturePredictor(chainer.Chain): """Wrapper that adds a prediction method to a feature extraction link. The :meth:`predict` takes three steps to make a prediction. 1. Preprocess input images 2. Forward the preprocessed images to the network 3. Average features in the case when more than one crops are extracted. Example: >>> from chainercv.links import VGG16 >>> from chainercv.links import FeaturePredictor >>> base_model = VGG16() >>> model = FeaturePredictor(base_model, 224, 256) >>> prob = model.predict([img]) # Predicting multiple features >>> model.extractor.pick = ['conv5_3', 'fc7'] >>> conv5_3, fc7 = model.predict([img]) When :obj:`self.crop == 'center'`, :meth:`predict` extracts features from the center crop of the input images. When :obj:`self.crop == '10'`, :meth:`predict` extracts features from patches that are ten-cropped from the input images. When extracting more than one crops from an image, the output of :meth:`predict` returns the average of the features computed from the crops. Args: extractor: A feature extraction link. This is a callable chain that takes a batch of images and returns a variable or a tuple of variables. crop_size (int or tuple): The height and the width of an image after cropping in preprocessing. If this is an integer, the image is cropped to :math:`(crop\_size, crop\_size)`. scale_size (int or tuple): If :obj:`scale_size` is :obj:`None`, neither scaling nor resizing is conducted during preprocessing. This is the default behavior. If this is an integer, an image is resized so that the length of the shorter edge is equal to :obj:`scale_size`. If this is a tuple :obj:`(height, width)`, the image is resized to :math:`(height, width)`. crop ({'center', '10'}): Determines the style of cropping. mean (numpy.ndarray): A mean value. If this is :obj:`None`, :obj:`extractor.mean` is used as the mean value. """ def __init__(self, extractor, crop_size, scale_size=None, crop='center', mean=None): super(FeaturePredictor, self).__init__() self.scale_size = scale_size if isinstance(crop_size, int): crop_size = (crop_size, crop_size) self.crop_size = crop_size self.crop = crop with self.init_scope(): self.extractor = extractor if mean is None: self.mean = self.extractor.mean else: self.mean = mean def _prepare(self, img): """Prepare an image for feeding it to a model. This is a standard preprocessing scheme used by feature extraction models. First, the image is scaled or resized according to :math:`scale_size`. Note that this step is optional. Next, the image is cropped to :math:`crop_size`. Last, the image is mean subtracted by an array :obj:`mean`. Args: img (~numpy.ndarray): An image. This is in CHW format. The range of its value is :math:`[0, 255]`. Returns: ~numpy.ndarray: A preprocessed image. This is 4D array whose batch size is the number of crops. """ if self.scale_size is not None: if isinstance(self.scale_size, int): img = scale(img, size=self.scale_size) else: img = resize(img, size=self.scale_size) else: img = img.copy() if self.crop == '10': imgs = ten_crop(img, self.crop_size) elif self.crop == 'center': imgs = center_crop(img, self.crop_size)[np.newaxis] imgs -= self.mean[np.newaxis] return imgs def _average_crops(self, y, n_crop): if y.ndim == 4: warnings.warn( 'Four dimensional features are averaged. ' 'If these are batch of 2D spatial features, ' 'their spatial information would be lost.') xp = chainer.backends.cuda.get_array_module(y) y = y.reshape((-1, n_crop) + y.shape[1:]) y = xp.mean(y, axis=1) return y def predict(self, imgs): """Predict features from images. Given :math:`N` input images, this method outputs a batched array with batchsize :math:`N`. Args: imgs (iterable of numpy.ndarray): Array-images. All images are in CHW format and the range of their value is :math:`[0, 255]`. Returns: numpy.ndarray or tuple of numpy.ndarray: A batch of features or a tuple of them. """ # [(C, H_0, W_0), ..., (C, H_{B-1}, W_{B-1})] -> (B, N, C, H, W) imgs = self.xp.asarray([self._prepare(img) for img in imgs]) n_crop = imgs.shape[-4] shape = (-1, imgs.shape[-3]) + self.crop_size # (B, N, C, H, W) -> (B * N, C, H, W) imgs = imgs.reshape(shape) with chainer.using_config('train', False), \ chainer.function.no_backprop_mode(): imgs = chainer.Variable(imgs) features = self.extractor(imgs) if isinstance(features, tuple): output = [] for feature in features: feature = feature.array if n_crop > 1: feature = self._average_crops(feature, n_crop) output.append(cuda.to_cpu(feature)) output = tuple(output) else: output = cuda.to_cpu(features.array) if n_crop > 1: output = self._average_crops(output, n_crop) return output "
" import argparse import imp import yaml from yaml.scanner import ScannerError TYPE = 'type' LIST = 'list' DESCRIPTION = 'description' REQUIRED = 'required' DEFAULT = 'default' ALLOWED = 'allowed' VALUES_DSC = 'values_description' ONE_OF = 'one of' SCHEMA = 'schema' EXAMPLES = 'examples' ANYOF = 'anyof' NO_DSC = '(no description)' VALIDATOR = 'validator' NoneType = type(None) class TextBlock(object): def __init__(self, text, tab_replacement=' ', ending=''): """ :type text: str """ self.text = str(text).replace('\t', tab_replacement) self.lines = self.text.splitlines() self.width = max([len(line) for line in self.lines] + [0]) self.padded_width = self.width + 2 self.height = len(self.lines) def get_line(self, item, raise_index_error=False, default=''): try: return self.lines[item] except IndexError: if raise_index_error: raise else: return default def get_line_justified(self, item, fillchar=' ', raise_index_error=False, default=''): return self.get_line(item, raise_index_error, default).ljust(self.width, fillchar) def __str__(self): return self.text def to_text_block(method): def decorated(content): if not isinstance(content, TextBlock): return method(TextBlock(content)) else: return method(TextBlock) return decorated class RSTRenderer(object): def with_escape(method): def escaped(content): return method(RSTRenderer.escape(content)) return escaped @staticmethod def any_of_table(blocks): """ :type blocks: list of TextBlock """ HEADER = 'any of' cnt = len(blocks) # no need table for single content if cnt < 2: return blocks[0] if blocks else '' # width = widths of contents + separators width = max((len(HEADER), sum([c.padded_width for c in blocks]))) + (cnt + 1) height = max([c.height for c in blocks]) # rows separators top_bar = '+{}+'.format('-' * (width - 2)) header_bar = '+{}+'.format('+'.join(['=' * c.padded_width for c in blocks])) bottom_bar = '+{}+'.format('+'.join(['-' * c.padded_width for c in blocks])) header = '|{}|'.format(HEADER.center(width - 2)) body = '\n'.join( ['| {} |'.format(' | '.join([c.get_line_justified(i) for c in blocks])) for i in range(height)]) return '\n'.join([top_bar, header, header_bar, body, bottom_bar]) @staticmethod def preserve_indents(block): """ :type block: TextBlock """ return '\n'.join(['| {}'.format(line) for line in block.lines]) @staticmethod def bold(content): """ :type content: str :return: str """ return '\n'.join(['**{}**'.format(line) for line in content.splitlines()]) @staticmethod def title(content, new_line_replacement=' ', tab_replacement=' '): """ Underlines content with '='. New lines and tabs will be replaced :param str content: :param str new_line_replacement: :param str tab_replacement: :return: str """ prepared_content = content.strip().replace('\n', new_line_replacement).replace('\t', tab_replacement) return '{}\n{}'.format(prepared_content, '=' * len(prepared_content)) @staticmethod def subtitle(content, new_line_replacement=' ', tab_replacement=' '): prepared_content = content.strip().replace('\n', new_line_replacement).replace('\t', tab_replacement) return '{}\n{}'.format(prepared_content, '-' * len(prepared_content)) @staticmethod @with_escape @to_text_block def italic(block): """ :type block: TextBlock """ return '\n'.join(['*{}*'.format(line) for line in block.lines]) @staticmethod @to_text_block def mono(block): """ :type block: TextBlock """ return '\n'.join(['``{}``'.format(line) for line in block.lines]) @classmethod def bullet_list(cls, blocks): """ :type blocks: list of TextBlock :rtype: TextBlock """ return TextBlock('\n'.join([cls._list_item(block) for block in blocks])) @staticmethod def _list_item(block): """ :type block: TextBlock """ return '- ' + '\n '.join(block.lines) @staticmethod def def_list(items, sort=True, newlines=True): def format_value(value): if isinstance(value, (int, bool, NoneType)): return format_value(str(value)) if isinstance(value, str): return '\n '.join(value.splitlines()) elif isinstance(value, TextBlock): return '\n '.join(value.lines) elif isinstance(value, dict): return '\n '.join(RSTRenderer.def_list(value, sort, newlines).splitlines()) elif isinstance(value, list): return '\n '.join(RSTRenderer.bullet_list([TextBlock(item) for item in value]).lines) else: raise ValueError('Unsupported value type: {}\n{}'.format(type(value), value)) sort = sorted if sort else lambda x: x template = '{}\n {}' if newlines else ':{}: {}' return '\n' + '\n'.join([template.format(k.replace('\n', ' '), format_value(v).strip()) for k, v in sort(items.items())]) if items else '' @staticmethod def field_list(items, sort=True, newlines=True): """ :param bool newlines: add newlines between names and values :param bool sort: sort items alphabetically by key :type items: dict :rtype: TextBlock """ def format_value(value): if isinstance(value, (int, bool, NoneType)): return format_value(str(value)) if isinstance(value, str): return '\n '.join(value.splitlines()) elif isinstance(value, TextBlock): return '\n '.join(value.lines) elif isinstance(value, dict): return '\n '.join(RSTRenderer.field_list(value, sort, newlines).splitlines()) elif isinstance(value, list): return '\n '.join(RSTRenderer.bullet_list([TextBlock(item) for item in value]).lines) else: raise ValueError('Unsupported value type: {}\n{}'.format(type(value), value)) sort = sorted if sort else lambda x: x template = ':{}:\n {}' if newlines else ':{}: {}' return '\n' + '\n'.join([template.format(k.replace('\n', ' '), format_value(v).strip()) for k, v in sort(items.items())]) if items else '' @staticmethod def dict_list_structure(items, sort_dict=True): if isinstance(items, str): return TextBlock(items) elif isinstance(items, int): return TextBlock(str(items)) elif isinstance(items, list): return RSTRenderer.bullet_list([RSTRenderer.dict_list_structure(item) for item in items]) elif isinstance(items, dict): return RSTRenderer.field_list({k: RSTRenderer.dict_list_structure(v) for k, v in items.items()}, sort_dict) @staticmethod def escape(content): """ :type content: str """ return content.replace('-', r'\-') del with_escape def render_body(renderer, option_kwargs, exclude_keys, special_keys=None): """ :type option_kwargs: dict :type exclude_keys: list :type special_keys: dict """ common_formatters = { EXAMPLES: lambda examples: renderer.def_list({renderer.mono(example): annotation for example, annotation in examples.items()}) } def default_fmt(x): return x special_keys = special_keys or {} special_part = '\n'.join([special_handler(renderer, option_kwargs[special_key]) for special_key, special_handler in special_keys.items() if special_key in option_kwargs]) uncommon_keys = set(exclude_keys) | set(special_keys.keys()) common_part = renderer.field_list({ k: common_formatters.get(k, default_fmt)(v) for k, v in option_kwargs.items() if k not in uncommon_keys }) return '\n'.join([_ for _ in [common_part, special_part] if _]) def render_values_description(renderer, option_kwargs): values_description_dict = { value: option_kwargs[VALUES_DSC].get(value, '') for value in option_kwargs[ALLOWED] } \ if ALLOWED in option_kwargs \ else \ option_kwargs[VALUES_DSC] values_description = renderer.field_list( {renderer.mono(value): dsc for value, dsc in values_description_dict.items()}, newlines=False ) return renderer.field_list({ONE_OF: values_description}) def allowed(renderer, values): return renderer.field_list({ONE_OF: '[{}]'.format(', '.join([renderer.mono(value) for value in values]))}, newlines=False) class OptionFormatter(object): def __init__(self, option_schema): """ :type option_schema: dict """ self.option_name, self.option_kwargs = next(iter(option_schema.items())) # print(option_name, option_kwargs) self.formatter = self.__guess_formatter() def format_dsc(self, renderer): dsc = self.option_kwargs.get(DESCRIPTION, NO_DSC).strip('. ') if DEFAULT in self.option_kwargs: default_value = self.option_kwargs.get(DEFAULT) if default_value == '': default_value = '""' return ' '.join([renderer.italic('- {}. Default:'.format(dsc)), renderer.mono(default_value)]) elif REQUIRED in self.option_kwargs: return renderer.italic('- {}.'.format(dsc)) +\ ' ' +\ renderer.bold('Required.') else: return renderer.italic('- {}.'.format(dsc)) def scalar_formatter(self, renderer, header=True): hdr = renderer.subtitle(renderer.mono(self.option_name) + ' ' + '({})'.format(self.option_kwargs.get(TYPE))) \ if header else '' dsc = self.format_dsc(renderer) body = render_body(renderer, self.option_kwargs, [VALIDATOR, TYPE, DESCRIPTION, DEFAULT, REQUIRED], {'allowed': allowed}) return '\n'.join([_ for _ in [hdr, dsc, body] if _]) def scalar_with_values_description(self, renderer, header=True): hdr = renderer.subtitle(renderer.mono(self.option_name) + ' ' + '({})'.format(self.option_kwargs.get(TYPE))) \ if header else '' dsc = self.format_dsc(renderer) body = render_body(renderer, self.option_kwargs, [VALIDATOR, TYPE, DESCRIPTION, DEFAULT, REQUIRED, ALLOWED, VALUES_DSC]) values_description_block = render_values_description(renderer, self.option_kwargs) return '\n'.join([_ for _ in [hdr, dsc, body, values_description_block] if _]) def dict_formatter(self, renderer, header=True): hdr = renderer.subtitle(renderer.mono(self.option_name) + ' ' + '({})'.format(self.option_kwargs.get(TYPE))) \ if header else '' dsc = self.format_dsc(renderer) dict_schema = self.option_kwargs[SCHEMA] schema_block = renderer.field_list({ '{} ({})'.format(renderer.mono(key), dict_schema[key].get(TYPE, 'anyof')): get_formatter({key: value})(renderer, header=False) for key, value in dict_schema.items()}) body = render_body(renderer, self.option_kwargs, [VALIDATOR, TYPE, DESCRIPTION, DEFAULT, REQUIRED, SCHEMA]) return '\n'.join([_ for _ in [hdr, dsc, schema_block, body] if _]) def anyof_formatter(self, renderer, header=True): types = [case[TYPE] for case in self.option_kwargs[ANYOF] if TYPE in case] hdr = renderer.subtitle(renderer.mono(self.option_name) + ' ' + '({})'.format(' or '.join(types))) \ if header else '' dsc = self.format_dsc(renderer) values_description_block = render_values_description(renderer, self.option_kwargs) \ if VALUES_DSC in self.option_kwargs else '' body = render_body(renderer, self.option_kwargs, [VALIDATOR, TYPE, DESCRIPTION, DEFAULT, REQUIRED, ANYOF, VALUES_DSC]) return '\n'.join([_ for _ in [hdr, dsc, values_description_block, body] if _]) def list_formatter(self, renderer, header=True): schema = self.option_kwargs[SCHEMA] hdr = renderer.subtitle(renderer.mono(self.option_name) + ' ' + '({} of {})'.format(self.option_kwargs.get(TYPE, LIST), schema.get(TYPE, ''))) dsc = self.format_dsc(renderer) body = render_body(renderer, self.option_kwargs, [VALIDATOR, TYPE, DEFAULT, REQUIRED, DESCRIPTION, SCHEMA]) if set(schema.keys()) - {TYPE}: schema_block = renderer.field_list({ '[list_element] ({})'.format(schema.get(TYPE, '')): get_formatter({'list_element': schema})(renderer, header=False) }) return '\n'.join([_ for _ in [hdr, dsc, schema_block, body] if _]) else: return '\n'.join([_ for _ in [hdr, dsc, body] if _]) def __guess_formatter(self): if ANYOF in self.option_kwargs: return self.anyof_formatter elif SCHEMA in self.option_kwargs: return self.list_formatter if self.option_kwargs.get(TYPE) == LIST else self.dict_formatter elif VALUES_DSC in self.option_kwargs: return self.scalar_with_values_description else: return self.scalar_formatter def get_formatter(option_schema): """ :type option_schema: dict """ return OptionFormatter(option_schema).formatter def format_option(option_schema, renderer): return get_formatter(option_schema)(renderer) def format_schema(schema, renderer, title=None): """ :param dict schema: Cerberus config schema :type renderer: RSTRenderer """ body = '\n\n'.join( sorted([format_option({option_name: option_schema}, renderer) for option_name, option_schema in schema.items()])) if title: title = renderer.title(title) return title + '\n\n' + body else: return body def main(): parser = argparse.ArgumentParser() parser.add_argument('schema', help='Path to schema file') parser.add_argument('-o', '--output_filename', default='output.rst', help='Name for the output rst document') parser.add_argument('--title', default=None, help='Document title') parser.add_argument('-a', '--append', action='store_true', help='Don\'t overwrite output file') args = parser.parse_args() schema_path = args.schema output_filename = args.output_filename title = args.title append = args.append try: with open(schema_path) as f: schema = yaml.load(f, Loader=yaml.FullLoader) except ScannerError: schema_module = imp.load_source('schema', schema_path) schema = schema_module.OPTIONS document = format_schema(schema, RSTRenderer(), title) if append: with open(output_filename, 'a') as f: f.write('\n\n') f.write(document) else: with open(output_filename, 'w') as f: f.write(document) if __name__ == '__main__': main() "
" from homeassistant.components.ozw.fan import SPEED_TO_VALUE from .common import setup_ozw async def test_fan(hass, fan_data, fan_msg, sent_messages, caplog): """Test fan.""" receive_message = await setup_ozw(hass, fixture=fan_data) # Test loaded state = hass.states.get("fan.in_wall_smart_fan_control_level") assert state is not None assert state.state == "on" # Test turning off await hass.services.async_call( "fan", "turn_off", {"entity_id": "fan.in_wall_smart_fan_control_level"}, blocking=True, ) assert len(sent_messages) == 1 msg = sent_messages[-1] assert msg["topic"] == "OpenZWave/1/command/setvalue/" assert msg["payload"] == {"Value": 0, "ValueIDKey": 172589073} # Feedback on state fan_msg.decode() fan_msg.payload["Value"] = 0 fan_msg.encode() receive_message(fan_msg) await hass.async_block_till_done() state = hass.states.get("fan.in_wall_smart_fan_control_level") assert state is not None assert state.state == "off" # Test turning on new_speed = "medium" await hass.services.async_call( "fan", "turn_on", {"entity_id": "fan.in_wall_smart_fan_control_level", "speed": new_speed}, blocking=True, ) assert len(sent_messages) == 2 msg = sent_messages[-1] assert msg["topic"] == "OpenZWave/1/command/setvalue/" assert msg["payload"] == { "Value": SPEED_TO_VALUE[new_speed], "ValueIDKey": 172589073, } # Feedback on state fan_msg.decode() fan_msg.payload["Value"] = SPEED_TO_VALUE[new_speed] fan_msg.encode() receive_message(fan_msg) await hass.async_block_till_done() state = hass.states.get("fan.in_wall_smart_fan_control_level") assert state is not None assert state.state == "on" assert state.attributes["speed"] == new_speed # Test turn on without speed await hass.services.async_call( "fan", "turn_on", {"entity_id": "fan.in_wall_smart_fan_control_level"}, blocking=True, ) assert len(sent_messages) == 3 msg = sent_messages[-1] assert msg["topic"] == "OpenZWave/1/command/setvalue/" assert msg["payload"] == { "Value": 255, "ValueIDKey": 172589073, } # Feedback on state fan_msg.decode() fan_msg.payload["Value"] = SPEED_TO_VALUE[new_speed] fan_msg.encode() receive_message(fan_msg) await hass.async_block_till_done() state = hass.states.get("fan.in_wall_smart_fan_control_level") assert state is not None assert state.state == "on" assert state.attributes["speed"] == new_speed # Test set speed to off new_speed = "off" await hass.services.async_call( "fan", "set_speed", {"entity_id": "fan.in_wall_smart_fan_control_level", "speed": new_speed}, blocking=True, ) assert len(sent_messages) == 4 msg = sent_messages[-1] assert msg["topic"] == "OpenZWave/1/command/setvalue/" assert msg["payload"] == { "Value": SPEED_TO_VALUE[new_speed], "ValueIDKey": 172589073, } # Feedback on state fan_msg.decode() fan_msg.payload["Value"] = SPEED_TO_VALUE[new_speed] fan_msg.encode() receive_message(fan_msg) await hass.async_block_till_done() state = hass.states.get("fan.in_wall_smart_fan_control_level") assert state is not None assert state.state == "off" # Test invalid speed new_speed = "invalid" await hass.services.async_call( "fan", "set_speed", {"entity_id": "fan.in_wall_smart_fan_control_level", "speed": new_speed}, blocking=True, ) assert len(sent_messages) == 4 assert "Invalid speed received: invalid" in caplog.text "
" from __future__ import print_function from pyVim.connect import SmartConnect, Disconnect from pyVmomi import vim, vmodl import argparse import atexit import getpass import sys import ssl def GetArgs(): """ Supports the command-line arguments listed below. """ parser = argparse.ArgumentParser(description='Process args for powering on a Virtual Machine') parser.add_argument('-s', '--host', required=True, action='store', help='Remote host to connect to') parser.add_argument('-o', '--port', type=int, default=443, action='store', help='Port to connect on') parser.add_argument('-u', '--user', required=True, action='store', help='User name to use when connecting to host') parser.add_argument('-p', '--password', required=False, action='store', help='Password to use when connecting to host') parser.add_argument('-v', '--vmname', required=True, action='append', help='Names of the Virtual Machines to power on') args = parser.parse_args() return args def WaitForTasks(tasks, si): """ Given the service instance si and tasks, it returns after all the tasks are complete """ pc = si.content.propertyCollector taskList = [str(task) for task in tasks] # Create filter objSpecs = [vmodl.query.PropertyCollector.ObjectSpec(obj=task) for task in tasks] propSpec = vmodl.query.PropertyCollector.PropertySpec(type=vim.Task, pathSet=[], all=True) filterSpec = vmodl.query.PropertyCollector.FilterSpec() filterSpec.objectSet = objSpecs filterSpec.propSet = [propSpec] filter = pc.CreateFilter(filterSpec, True) try: version, state = None, None # Loop looking for updates till the state moves to a completed state. while len(taskList): update = pc.WaitForUpdates(version) for filterSet in update.filterSet: for objSet in filterSet.objectSet: task = objSet.obj for change in objSet.changeSet: if change.name == 'info': state = change.val.state elif change.name == 'info.state': state = change.val else: continue if not str(task) in taskList: continue if state == vim.TaskInfo.State.success: # Remove task from taskList taskList.remove(str(task)) elif state == vim.TaskInfo.State.error: raise task.info.error # Move to next version version = update.version finally: if filter: filter.Destroy() # Start program def main(): """ Simple command-line program for powering on virtual machines on a system. """ args = GetArgs() if args.password: password = args.password else: password = getpass.getpass(prompt='Enter password for host %s and user %s: ' % (args.host,args.user)) try: vmnames = args.vmname if not len(vmnames): print("No virtual machine specified for poweron") sys.exit() context = None if hasattr(ssl, '_create_unverified_context'): context = ssl._create_unverified_context() si = SmartConnect(host=args.host, user=args.user, pwd=password, port=int(args.port), sslContext=context) if not si: print("Cannot connect to specified host using specified username and password") sys.exit() atexit.register(Disconnect, si) # Retreive the list of Virtual Machines from the inventory objects # under the rootFolder content = si.content objView = content.viewManager.CreateContainerView(content.rootFolder, [vim.VirtualMachine], True) vmList = objView.view objView.Destroy() # Find the vm and power it on tasks = [vm.PowerOn() for vm in vmList if vm.name in vmnames] # Wait for power on to complete WaitForTasks(tasks, si) print("Virtual Machine(s) have been powered on successfully") except vmodl.MethodFault as e: print("Caught vmodl fault : " + e.msg) except Exception as e: print("Caught Exception : " + str(e)) # Start program if __name__ == "__main__": main() "
" from homeassistant.const import STATE_OFF, STATE_ON from .util import async_init_integration async def test_create_binary_sensors(hass): """Test creation of binary sensors.""" await async_init_integration(hass) state = hass.states.get("binary_sensor.master_suite_blower_active") assert state.state == STATE_ON expected_attributes = { "attribution": "Data provided by mynexia.com", "friendly_name": "Master Suite Blower Active", } # Only test for a subset of attributes in case # HA changes the implementation and a new one appears assert all( state.attributes[key] == expected_attributes[key] for key in expected_attributes ) state = hass.states.get("binary_sensor.downstairs_east_wing_blower_active") assert state.state == STATE_OFF expected_attributes = { "attribution": "Data provided by mynexia.com", "friendly_name": "Downstairs East Wing Blower Active", } # Only test for a subset of attributes in case # HA changes the implementation and a new one appears assert all( state.attributes[key] == expected_attributes[key] for key in expected_attributes ) "
" import numpy as np import pandas as pd class PhraseSelector(object): def __init__(self, minimum_pmi=16): ''' Filter n-grams using PMI. Parameters ---------- alpha : float labmda_ : "cressie_read" See https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.power_divergence.html for options. ''' self.minimum_pmi = minimum_pmi def compact(self, term_doc_matrix, non_text=False): ''' Parameters ------- term_doc_matrix : TermDocMatrix Returns ------- New term doc matrix ''' count_df = self._get_statistics_dataframe(term_doc_matrix, non_text) return term_doc_matrix.remove_terms( count_df[count_df['pmi'] < self.minimum_pmi].index, non_text=non_text ) def _get_statistics_dataframe(self, term_doc_matrix, non_text): tdf = (term_doc_matrix.get_metadata_freq_df().sum(axis=1) if non_text else term_doc_matrix.get_term_freq_df().sum(axis=1)) gram_df = pd.Series(tdf.index).apply(lambda x: pd.Series(list(reversed(x.split())))) gram_df['c'] = tdf.values gram_df['term'] = tdf.index gram_df = gram_df.set_index('term') unigram_df = gram_df[gram_df[1].isnull()][['c']] ngram_df = gram_df.dropna() count_df = pd.merge(pd.merge(ngram_df, unigram_df, left_on=0, right_index=True, suffixes=('', '0')), unigram_df, left_on=1, right_index=True, suffixes=('', '1')) p0 = count_df['c0'] / unigram_df['c'].sum() p1 = count_df['c1'] / unigram_df['c'].sum() p = count_df['c'] / ngram_df['c'].sum() count_df['pmi'] = np.log(p / (p0 * p1)) / np.log(2) return count_df "
" import os import os.path as op from numpy.testing import assert_array_equal from mne.utils import requires_mayavi, run_tests_if_main, traits_test @requires_mayavi @traits_test def test_mri_model(subjects_dir_tmp): """Test MRIHeadWithFiducialsModel Traits Model.""" from mne.gui._fiducials_gui import MRIHeadWithFiducialsModel tgt_fname = op.join(subjects_dir_tmp, 'test-fiducials.fif') # Remove the two files that will make the fiducials okay via MNI estimation os.remove(op.join(subjects_dir_tmp, 'sample', 'bem', 'sample-fiducials.fif')) os.remove(op.join(subjects_dir_tmp, 'sample', 'mri', 'transforms', 'talairach.xfm')) model = MRIHeadWithFiducialsModel(subjects_dir=subjects_dir_tmp) model.subject = 'sample' assert model.default_fid_fname[-20:] == "sample-fiducials.fif" assert not model.can_reset assert not model.can_save model.lpa = [[-1, 0, 0]] model.nasion = [[0, 1, 0]] model.rpa = [[1, 0, 0]] assert not model.can_reset assert model.can_save bem_fname = op.basename(model.bem_high_res.file) assert not model.can_reset assert bem_fname == 'sample-head-dense.fif' model.save(tgt_fname) assert model.fid_file == tgt_fname # resetting the file should not affect the model's fiducials model.fid_file = '' assert_array_equal(model.lpa, [[-1, 0, 0]]) assert_array_equal(model.nasion, [[0, 1, 0]]) assert_array_equal(model.rpa, [[1, 0, 0]]) # reset model model.lpa = [[0, 0, 0]] model.nasion = [[0, 0, 0]] model.rpa = [[0, 0, 0]] assert_array_equal(model.lpa, [[0, 0, 0]]) assert_array_equal(model.nasion, [[0, 0, 0]]) assert_array_equal(model.rpa, [[0, 0, 0]]) # loading the file should assign the model's fiducials model.fid_file = tgt_fname assert_array_equal(model.lpa, [[-1, 0, 0]]) assert_array_equal(model.nasion, [[0, 1, 0]]) assert_array_equal(model.rpa, [[1, 0, 0]]) # after changing from file model should be able to reset model.nasion = [[1, 1, 1]] assert model.can_reset model.reset = True assert_array_equal(model.nasion, [[0, 1, 0]]) run_tests_if_main() "
" import logging import voluptuous as vol from homeassistant.components.mqtt import valid_publish_topic, valid_subscribe_topic from homeassistant.const import CONF_OPTIMISTIC from homeassistant.core import callback import homeassistant.helpers.config_validation as cv from .const import ( ATTR_DEVICES, CONF_BAUD_RATE, CONF_DEVICE, CONF_GATEWAYS, CONF_NODES, CONF_PERSISTENCE, CONF_PERSISTENCE_FILE, CONF_RETAIN, CONF_TCP_PORT, CONF_TOPIC_IN_PREFIX, CONF_TOPIC_OUT_PREFIX, CONF_VERSION, DOMAIN, MYSENSORS_GATEWAYS, ) from .device import get_mysensors_devices from .gateway import finish_setup, get_mysensors_gateway, setup_gateways _LOGGER = logging.getLogger(__name__) CONF_DEBUG = "debug" CONF_NODE_NAME = "name" DEFAULT_BAUD_RATE = 115200 DEFAULT_TCP_PORT = 5003 DEFAULT_VERSION = "1.4" def has_all_unique_files(value): """Validate that all persistence files are unique and set if any is set.""" persistence_files = [gateway.get(CONF_PERSISTENCE_FILE) for gateway in value] if None in persistence_files and any( name is not None for name in persistence_files ): raise vol.Invalid( "persistence file name of all devices must be set if any is set" ) if not all(name is None for name in persistence_files): schema = vol.Schema(vol.Unique()) schema(persistence_files) return value def is_persistence_file(value): """Validate that persistence file path ends in either .pickle or .json.""" if value.endswith((".json", ".pickle")): return value raise vol.Invalid(f"{value} does not end in either `.json` or `.pickle`") def deprecated(key): """Mark key as deprecated in configuration.""" def validator(config): """Check if key is in config, log warning and remove key.""" if key not in config: return config _LOGGER.warning( "%s option for %s is deprecated. Please remove %s from your " "configuration file", key, DOMAIN, key, ) config.pop(key) return config return validator NODE_SCHEMA = vol.Schema({cv.positive_int: {vol.Required(CONF_NODE_NAME): cv.string}}) GATEWAY_SCHEMA = { vol.Required(CONF_DEVICE): cv.string, vol.Optional(CONF_PERSISTENCE_FILE): vol.All(cv.string, is_persistence_file), vol.Optional(CONF_BAUD_RATE, default=DEFAULT_BAUD_RATE): cv.positive_int, vol.Optional(CONF_TCP_PORT, default=DEFAULT_TCP_PORT): cv.port, vol.Optional(CONF_TOPIC_IN_PREFIX): valid_subscribe_topic, vol.Optional(CONF_TOPIC_OUT_PREFIX): valid_publish_topic, vol.Optional(CONF_NODES, default={}): NODE_SCHEMA, } CONFIG_SCHEMA = vol.Schema( { DOMAIN: vol.Schema( vol.All( deprecated(CONF_DEBUG), { vol.Required(CONF_GATEWAYS): vol.All( cv.ensure_list, has_all_unique_files, [GATEWAY_SCHEMA] ), vol.Optional(CONF_OPTIMISTIC, default=False): cv.boolean, vol.Optional(CONF_PERSISTENCE, default=True): cv.boolean, vol.Optional(CONF_RETAIN, default=True): cv.boolean, vol.Optional(CONF_VERSION, default=DEFAULT_VERSION): cv.string, }, ) ) }, extra=vol.ALLOW_EXTRA, ) async def async_setup(hass, config): """Set up the MySensors component.""" gateways = await setup_gateways(hass, config) if not gateways: _LOGGER.error("No devices could be setup as gateways, check your configuration") return False hass.data[MYSENSORS_GATEWAYS] = gateways hass.async_create_task(finish_setup(hass, config, gateways)) return True def _get_mysensors_name(gateway, node_id, child_id): """Return a name for a node child.""" node_name = f"{gateway.sensors[node_id].sketch_name} {node_id}" node_name = next( ( node[CONF_NODE_NAME] for conf_id, node in gateway.nodes_config.items() if node.get(CONF_NODE_NAME) is not None and conf_id == node_id ), node_name, ) return f"{node_name} {child_id}" @callback def setup_mysensors_platform( hass, domain, discovery_info, device_class, device_args=None, async_add_entities=None, ): """Set up a MySensors platform.""" # Only act if called via MySensors by discovery event. # Otherwise gateway is not set up. if not discovery_info: return None if device_args is None: device_args = () new_devices = [] new_dev_ids = discovery_info[ATTR_DEVICES] for dev_id in new_dev_ids: devices = get_mysensors_devices(hass, domain) if dev_id in devices: continue gateway_id, node_id, child_id, value_type = dev_id gateway = get_mysensors_gateway(hass, gateway_id) if not gateway: continue device_class_copy = device_class if isinstance(device_class, dict): child = gateway.sensors[node_id].children[child_id] s_type = gateway.const.Presentation(child.type).name device_class_copy = device_class[s_type] name = _get_mysensors_name(gateway, node_id, child_id) args_copy = (*device_args, gateway, node_id, child_id, name, value_type) devices[dev_id] = device_class_copy(*args_copy) new_devices.append(devices[dev_id]) if new_devices: _LOGGER.info("Adding new devices: %s", new_devices) if async_add_entities is not None: async_add_entities(new_devices, True) return new_devices "
" from collections import Counter from scattertext.features.FeatsFromSpacyDoc import FeatsFromSpacyDoc class PyatePhrases(FeatsFromSpacyDoc): def __init__(self, extractor=None, **args): import pyate self._extractor = pyate.combo_basic if extractor is None else extractor FeatsFromSpacyDoc.__init__(self, **args) def get_feats(self, doc): return Counter(self._extractor(str(doc)).to_dict()) "
" from collections import deque from functools import partial from io import BytesIO from time import time from kombu.asynchronous.hub import READ, WRITE, get_event_loop from kombu.exceptions import HttpError from kombu.utils.encoding import bytes_to_str from .base import BaseClient try: import pycurl # noqa except ImportError: # pragma: no cover pycurl = Curl = METH_TO_CURL = None # noqa else: from pycurl import Curl # noqa METH_TO_CURL = { # noqa 'GET': pycurl.HTTPGET, 'POST': pycurl.POST, 'PUT': pycurl.UPLOAD, 'HEAD': pycurl.NOBODY, } __all__ = ('CurlClient',) DEFAULT_USER_AGENT = 'Mozilla/5.0 (compatible; pycurl)' EXTRA_METHODS = frozenset(['DELETE', 'OPTIONS', 'PATCH']) class CurlClient(BaseClient): """Curl HTTP Client.""" Curl = Curl def __init__(self, hub=None, max_clients=10): if pycurl is None: raise ImportError('The curl client requires the pycurl library.') hub = hub or get_event_loop() super().__init__(hub) self.max_clients = max_clients self._multi = pycurl.CurlMulti() self._multi.setopt(pycurl.M_TIMERFUNCTION, self._set_timeout) self._multi.setopt(pycurl.M_SOCKETFUNCTION, self._handle_socket) self._curls = [self.Curl() for i in range(max_clients)] self._free_list = self._curls[:] self._pending = deque() self._fds = {} self._socket_action = self._multi.socket_action self._timeout_check_tref = self.hub.call_repeatedly( 1.0, self._timeout_check, ) # pycurl 7.29.0 workaround dummy_curl_handle = pycurl.Curl() self._multi.add_handle(dummy_curl_handle) self._multi.remove_handle(dummy_curl_handle) def close(self): self._timeout_check_tref.cancel() for _curl in self._curls: _curl.close() self._multi.close() def add_request(self, request): self._pending.append(request) self._process_queue() self._set_timeout(0) return request # the next two methods are used for linux/epoll workaround: # we temporarily remove all curl fds from hub, so curl cannot # close a fd which is still inside epoll def _pop_from_hub(self): for fd in self._fds: self.hub.remove(fd) def _push_to_hub(self): for fd, events in self._fds.items(): if events & READ: self.hub.add_reader(fd, self.on_readable, fd) if events & WRITE: self.hub.add_writer(fd, self.on_writable, fd) def _handle_socket(self, event, fd, multi, data, _pycurl=pycurl): if event == _pycurl.POLL_REMOVE: if fd in self._fds: self._fds.pop(fd, None) else: if event == _pycurl.POLL_IN: self._fds[fd] = READ elif event == _pycurl.POLL_OUT: self._fds[fd] = WRITE elif event == _pycurl.POLL_INOUT: self._fds[fd] = READ | WRITE def _set_timeout(self, msecs): pass # TODO def _timeout_check(self, _pycurl=pycurl): self._pop_from_hub() try: while 1: try: ret, _ = self._multi.socket_all() except pycurl.error as exc: ret = exc.args[0] if ret != _pycurl.E_CALL_MULTI_PERFORM: break finally: self._push_to_hub() self._process_pending_requests() def on_readable(self, fd, _pycurl=pycurl): return self._on_event(fd, _pycurl.CSELECT_IN) def on_writable(self, fd, _pycurl=pycurl): return self._on_event(fd, _pycurl.CSELECT_OUT) def _on_event(self, fd, event, _pycurl=pycurl): self._pop_from_hub() try: while 1: try: ret, _ = self._socket_action(fd, event) except pycurl.error as exc: ret = exc.args[0] if ret != _pycurl.E_CALL_MULTI_PERFORM: break finally: self._push_to_hub() self._process_pending_requests() def _process_pending_requests(self): while 1: q, succeeded, failed = self._multi.info_read() for curl in succeeded: self._process(curl) for curl, errno, reason in failed: self._process(curl, errno, reason) if q == 0: break self._process_queue() def _process_queue(self): while 1: started = 0 while self._free_list and self._pending: started += 1 curl = self._free_list.pop() request = self._pending.popleft() headers = self.Headers() buf = BytesIO() curl.info = { 'headers': headers, 'buffer': buf, 'request': request, 'curl_start_time': time(), } self._setup_request(curl, request, buf, headers) self._multi.add_handle(curl) if not started: break def _process(self, curl, errno=None, reason=None, _pycurl=pycurl): info, curl.info = curl.info, None self._multi.remove_handle(curl) self._free_list.append(curl) buffer = info['buffer'] if errno: code = 599 error = HttpError(code, reason) error.errno = errno effective_url = None buffer.close() buffer = None else: error = None code = curl.getinfo(_pycurl.HTTP_CODE) effective_url = curl.getinfo(_pycurl.EFFECTIVE_URL) buffer.seek(0) # try: request = info['request'] request.on_ready(self.Response( request=request, code=code, headers=info['headers'], buffer=buffer, effective_url=effective_url, error=error, )) def _setup_request(self, curl, request, buffer, headers, _pycurl=pycurl): setopt = curl.setopt setopt(_pycurl.URL, bytes_to_str(request.url)) # see tornado curl client request.headers.setdefault('Expect', '') request.headers.setdefault('Pragma', '') setopt( _pycurl.HTTPHEADER, ['{}: {}'.format(*h) for h in request.headers.items()], ) setopt( _pycurl.HEADERFUNCTION, partial(request.on_header or self.on_header, request.headers), ) setopt( _pycurl.WRITEFUNCTION, request.on_stream or buffer.write, ) setopt( _pycurl.FOLLOWLOCATION, request.follow_redirects, ) setopt( _pycurl.USERAGENT, bytes_to_str(request.user_agent or DEFAULT_USER_AGENT), ) if request.network_interface: setopt(_pycurl.INTERFACE, request.network_interface) setopt( _pycurl.ENCODING, 'gzip,deflate' if request.use_gzip else 'none', ) if request.proxy_host: if not request.proxy_port: raise ValueError('Request with proxy_host but no proxy_port') setopt(_pycurl.PROXY, request.proxy_host) setopt(_pycurl.PROXYPORT, request.proxy_port) if request.proxy_username: setopt(_pycurl.PROXYUSERPWD, '{}:{}'.format( request.proxy_username, request.proxy_password or '')) else: setopt(_pycurl.PROXY, '') curl.unsetopt(_pycurl.PROXYUSERPWD) setopt(_pycurl.SSL_VERIFYPEER, 1 if request.validate_cert else 0) setopt(_pycurl.SSL_VERIFYHOST, 2 if request.validate_cert else 0) if request.ca_certs is not None: setopt(_pycurl.CAINFO, request.ca_certs) setopt(_pycurl.IPRESOLVE, pycurl.IPRESOLVE_WHATEVER) for meth in METH_TO_CURL.values(): setopt(meth, False) try: meth = METH_TO_CURL[request.method] except KeyError: curl.setopt(_pycurl.CUSTOMREQUEST, request.method) else: curl.unsetopt(_pycurl.CUSTOMREQUEST) setopt(meth, True) if request.method in ('POST', 'PUT'): body = request.body.encode('utf-8') if request.body else bytes() reqbuffer = BytesIO(body) setopt(_pycurl.READFUNCTION, reqbuffer.read) if request.method == 'POST': def ioctl(cmd): if cmd == _pycurl.IOCMD_RESTARTREAD: reqbuffer.seek(0) setopt(_pycurl.IOCTLFUNCTION, ioctl) setopt(_pycurl.POSTFIELDSIZE, len(body)) else: setopt(_pycurl.INFILESIZE, len(body)) elif request.method == 'GET': assert not request.body if request.auth_username is not None: auth_mode = { 'basic': _pycurl.HTTPAUTH_BASIC, 'digest': _pycurl.HTTPAUTH_DIGEST }[request.auth_mode or 'basic'] setopt(_pycurl.HTTPAUTH, auth_mode) userpwd = '{}:{}'.format( request.auth_username, request.auth_password or '', ) setopt(_pycurl.USERPWD, userpwd) else: curl.unsetopt(_pycurl.USERPWD) if request.client_cert is not None: setopt(_pycurl.SSLCERT, request.client_cert) if request.client_key is not None: setopt(_pycurl.SSLKEY, request.client_key) if request.on_prepare is not None: request.on_prepare(curl) "
" from unittest import TestCase import pandas as pd from scattertext.CorpusFromParsedDocuments import CorpusFromParsedDocuments from scattertext.WhitespaceNLP import whitespace_nlp from scattertext.representations.Word2VecFromParsedCorpus import GensimPhraseAdder from scattertext.test.test_corpusFromPandas import get_docs_categories class TestGensimPhraseAdder(TestCase): @classmethod def setUp(cls): cls.categories, cls.documents = get_docs_categories() cls.parsed_docs = [] for doc in cls.documents: cls.parsed_docs.append(whitespace_nlp(doc)) cls.df = pd.DataFrame({'category': cls.categories, 'author': ['a', 'a', 'c', 'c', 'c', 'c', 'd', 'd', 'e', 'e'], 'parsed': cls.parsed_docs, 'document_lengths': [len(doc) for doc in cls.documents]}) cls.corpus = CorpusFromParsedDocuments(cls.df, 'category', 'parsed').build() def test_add_phrase(self): adder = GensimPhraseAdder() # to do #res = adder.add_phrases(self.corpus) # self.fail() "
" import logging SUPPORTED_SCALING_FACTORS = [(7, 8), (3, 4), (5, 8), (1, 2), (3, 8), (1, 4), (1, 8)] _LOGGER = logging.getLogger(__name__) def scale_jpeg_camera_image(cam_image, width, height): """Scale a camera image as close as possible to one of the supported scaling factors.""" turbo_jpeg = TurboJPEGSingleton.instance() if not turbo_jpeg: return cam_image.content (current_width, current_height, _, _) = turbo_jpeg.decode_header(cam_image.content) if current_width <= width or current_height <= height: return cam_image.content ratio = width / current_width scaling_factor = SUPPORTED_SCALING_FACTORS[-1] for supported_sf in SUPPORTED_SCALING_FACTORS: if ratio >= (supported_sf[0] / supported_sf[1]): scaling_factor = supported_sf break return turbo_jpeg.scale_with_quality( cam_image.content, scaling_factor=scaling_factor, quality=75, ) class TurboJPEGSingleton: """ Load TurboJPEG only once. Ensures we do not log load failures each snapshot since camera image fetches happen every few seconds. """ __instance = None @staticmethod def instance(): """Singleton for TurboJPEG.""" if TurboJPEGSingleton.__instance is None: TurboJPEGSingleton() return TurboJPEGSingleton.__instance def __init__(self): """Try to create TurboJPEG only once.""" try: # TurboJPEG checks for libturbojpeg # when its created, but it imports # numpy which may or may not work so # we have to guard the import here. from turbojpeg import TurboJPEG # pylint: disable=import-outside-toplevel TurboJPEGSingleton.__instance = TurboJPEG() except Exception: # pylint: disable=broad-except _LOGGER.exception( "libturbojpeg is not installed, cameras may impact HomeKit performance" ) TurboJPEGSingleton.__instance = False "
" from gitless import core from . import helpers, pprint def parser(subparsers, _): """Adds the tag parser to the given subparsers object.""" desc = 'list, create, or delete tags' tag_parser = subparsers.add_parser( 'tag', help=desc, description=desc.capitalize(), aliases=['tg']) list_group = tag_parser.add_argument_group('list tags') list_group.add_argument( '-r', '--remote', help='list remote tags in addition to local tags', action='store_true') create_group = tag_parser.add_argument_group('create tags') create_group.add_argument( '-c', '--create', nargs='+', help='create tag(s)', dest='create_t', metavar='tag') create_group.add_argument( '-ci', '--commit', help='the commit to tag (only relevant if a new ' 'tag is created; defaults to the HEAD commit)', dest='ci') delete_group = tag_parser.add_argument_group('delete tags') delete_group.add_argument( '-d', '--delete', nargs='+', help='delete tag(s)', dest='delete_t', metavar='tag') tag_parser.set_defaults(func=main) def main(args, repo): is_list = bool(args.remote) is_create = bool(args.create_t or args.ci) is_delete = bool(args.delete_t) if is_list + is_create + is_delete > 1: pprint.err('Invalid flag combination') pprint.err_exp('Can only do one of list, create, or delete tags at a time') return False ret = True if args.create_t: ret = _do_create(args.create_t, args.ci or 'HEAD', repo) elif args.delete_t: ret = _do_delete(args.delete_t, repo) else: _do_list(repo, args.remote) return ret def _do_list(repo, list_remote): pprint.msg('List of tags:') pprint.exp('do gl tag -c t to create tag t') pprint.exp('do gl tag -d t to delete tag t') pprint.blank() no_tags = True for t in (repo.lookup_tag(n) for n in sorted(repo.listall_tags())): pprint.item('{0} ➜ tags {1}'.format(t, pprint.commit_str(t.commit))) no_tags = False if list_remote: for r in sorted(repo.remotes, key=lambda r: r.name): for t in (r.lookup_tag(n) for n in sorted(r.listall_tags())): pprint.item('{0} ➜ tags {1}'.format(t, pprint.commit_str(t.commit))) no_tags = False if no_tags: pprint.item('There are no tags to list') def _do_create(create_t, dp, repo): errors_found = False try: target = repo.revparse_single(dp) except KeyError: raise ValueError('Invalid commit {0}'.format(dp)) for t_name in create_t: r = repo remote_str = '' if '/' in t_name: # might want to create a remote tag maybe_remote, maybe_remote_tag = t_name.split('/', 1) if maybe_remote in repo.remotes: r = repo.remotes[maybe_remote] t_name = maybe_remote_tag conf_msg = 'Tag {0} will be created in remote repository {1}'.format( t_name, maybe_remote) if not pprint.conf_dialog(conf_msg): pprint.msg( 'Aborted: creation of tag {0} in remote repository {1}'.format( t_name, maybe_remote)) continue remote_str = ' in remote repository {0}'.format(maybe_remote) try: r.create_tag(t_name, target) pprint.ok('Created new tag {0}{1}'.format(t_name, remote_str)) except ValueError as e: pprint.err(e) errors_found = True return not errors_found def _do_delete(delete_t, repo): errors_found = False for t_name in delete_t: try: t = helpers.get_tag(t_name, repo) tag_str = 'Tag {0} will be removed'.format(t.tag_name) remote_str = '' if isinstance(t, core.RemoteTag): remote_str = 'from remote repository {0}'.format(t.remote_name) if not pprint.conf_dialog('{0} {1}'.format(tag_str, remote_str)): pprint.msg('Aborted: removal of tag {0}'.format(t)) continue t.delete() pprint.ok('Tag {0} removed successfully'.format(t)) except ValueError as e: pprint.err(e) errors_found = True return not errors_found "
" import warnings from typing import Awaitable, TYPE_CHECKING, Dict import discord from .commands import ( bot_has_permissions, bot_in_a_guild, has_permissions, is_owner, guildowner, guildowner_or_permissions, admin, admin_or_permissions, mod, mod_or_permissions, ) from .utils.mod import ( is_mod_or_superior as _is_mod_or_superior, is_admin_or_superior as _is_admin_or_superior, check_permissions as _check_permissions, ) if TYPE_CHECKING: from .bot import Red from .commands import Context __all__ = [ "bot_has_permissions", "bot_in_a_guild", "has_permissions", "is_owner", "guildowner", "guildowner_or_permissions", "admin", "admin_or_permissions", "mod", "mod_or_permissions", "is_mod_or_superior", "is_admin_or_superior", "check_permissions", ] def is_mod_or_superior(ctx: "Context") -> Awaitable[bool]: warnings.warn( "`redbot.core.checks.is_mod_or_superior` is deprecated and will be removed in a future " "release, please use `redbot.core.utils.mod.is_mod_or_superior` instead.", category=DeprecationWarning, stacklevel=2, ) return _is_mod_or_superior(ctx.bot, ctx.author) def is_admin_or_superior(ctx: "Context") -> Awaitable[bool]: warnings.warn( "`redbot.core.checks.is_admin_or_superior` is deprecated and will be removed in a future " "release, please use `redbot.core.utils.mod.is_admin_or_superior` instead.", category=DeprecationWarning, stacklevel=2, ) return _is_admin_or_superior(ctx.bot, ctx.author) def check_permissions(ctx: "Context", perms: Dict[str, bool]) -> Awaitable[bool]: warnings.warn( "`redbot.core.checks.check_permissions` is deprecated and will be removed in a future " "release, please use `redbot.core.utils.mod.check_permissions`.", DeprecationWarning, stacklevel=2, ) return _check_permissions(ctx, perms) "
" from contextlib import contextmanager from datetime import datetime import mock from freezegun import freeze_time from paasta_tools.autoscaling import load_boost TEST_CURRENT_TIME = datetime(2020, 2, 14) @contextmanager def patch_zk_client(mock_values=None): with mock.patch( "paasta_tools.utils.KazooClient", autospec=True ) as mock_client, mock.patch( "paasta_tools.utils.load_system_paasta_config", autospec=True ): def mock_get(key): if not mock_values or key not in mock_values: raise load_boost.NoNodeError return (mock_values[key], None) mock_client.return_value = mock.Mock(get=mock_get) yield mock_client() def test_get_zk_cluster_boost_path(): fake_region = "westeros-1" fake_pool = "default" expected_result = "/paasta_cluster_autoscaler/westeros-1/default/boost" assert ( load_boost.get_zk_cluster_boost_path(fake_region, fake_pool) == expected_result ) def test_get_boost_values(): fake_region = "westeros-1" fake_pool = "default" base_path = load_boost.get_zk_cluster_boost_path(fake_region, fake_pool) fake_end_time = 12345.0 fake_boost_factor = 1.5 fake_expected_load = 80 with patch_zk_client( { base_path + "/end_time": str(fake_end_time).encode("utf-8"), base_path + "/factor": str(fake_boost_factor).encode("utf-8"), base_path + "/expected_load": str(fake_expected_load).encode("utf-8"), } ) as mock_zk_client: assert load_boost.get_boost_values( zk_boost_path=f"/paasta_cluster_autoscaler/{fake_region}/{fake_pool}/boost", zk=mock_zk_client, ) == load_boost.BoostValues( end_time=fake_end_time, boost_factor=fake_boost_factor, expected_load=fake_expected_load, ) def test_get_boost_values_when_no_values_exist(): fake_region = "westeros-1" fake_pool = "default" with patch_zk_client() as mock_zk_client: assert load_boost.get_boost_values( zk_boost_path=f"/paasta_cluster_autoscaler/{fake_region}/{fake_pool}/boost", zk=mock_zk_client, ) == load_boost.BoostValues(end_time=0, boost_factor=1.0, expected_load=0) @freeze_time(TEST_CURRENT_TIME) def test_set_boost_factor_with_defaults(): fake_region = "westeros-1" fake_pool = "default" base_path = load_boost.get_zk_cluster_boost_path(fake_region, fake_pool) with patch_zk_client() as mock_zk_client: load_boost.set_boost_factor(base_path) expected_end_time = ( float(TEST_CURRENT_TIME.timestamp()) + 60 * load_boost.DEFAULT_BOOST_DURATION ) assert mock_zk_client.set.call_args_list == [ mock.call(base_path + "/end_time", str(expected_end_time).encode("utf-8")), mock.call( base_path + "/factor", str(load_boost.DEFAULT_BOOST_FACTOR).encode("utf-8") ), mock.call(base_path + "/expected_load", "0".encode("utf-8")), ] def test_set_boost_factor(): pass @freeze_time(TEST_CURRENT_TIME) def test_set_boost_factor_with_active_boost(): fake_region = "westeros-1" fake_pool = "default" base_path = load_boost.get_zk_cluster_boost_path(fake_region, fake_pool) fake_end_time = float(TEST_CURRENT_TIME.timestamp()) + 10 fake_boost_factor = 1.5 fake_expected_load = 80 # patch zk client so that it returns an end time that # indicates an active boost with patch_zk_client( { base_path + "/end_time": str(fake_end_time).encode("utf-8"), base_path + "/factor": str(fake_boost_factor).encode("utf-8"), base_path + "/expected_load": str(fake_expected_load).encode("utf-8"), } ): # by default, set boost should not go through if there's an active boost assert not load_boost.set_boost_factor(zk_boost_path=base_path) @freeze_time(TEST_CURRENT_TIME) def test_set_boost_factor_with_active_boost_override(): fake_region = "westeros-1" fake_pool = "default" base_path = load_boost.get_zk_cluster_boost_path(fake_region, fake_pool) fake_end_time = float(TEST_CURRENT_TIME.timestamp()) + 10 fake_boost_factor = 1.5 fake_expected_load = 80 mock_boost_values = { base_path + "/end_time": str(fake_end_time).encode("utf-8"), base_path + "/factor": str(fake_boost_factor).encode("utf-8"), base_path + "/expected_load": str(fake_expected_load).encode("utf-8"), } # patch zk client so that it returns an end time that # indicates an active boost with patch_zk_client(mock_boost_values) as mock_zk_client: # we need the zk.set to actually override the initial mocked values def mock_set(key, value): mock_boost_values[key] = value mock_zk_client.set = mock_set # set boost will go through with an active boost if override is toggled on assert load_boost.set_boost_factor( zk_boost_path=f"/paasta_cluster_autoscaler/{fake_region}/{fake_pool}/boost", override=True, ) @freeze_time(TEST_CURRENT_TIME) def test_clear_boost(): fake_region = "westeros-1" fake_pool = "default" base_path = load_boost.get_zk_cluster_boost_path(fake_region, fake_pool) with patch_zk_client() as mock_zk_client: load_boost.clear_boost(base_path, region=fake_region, pool=fake_pool) expected_end_time = float(TEST_CURRENT_TIME.timestamp()) assert mock_zk_client.set.call_args_list == [ mock.call(base_path + "/end_time", str(expected_end_time).encode("utf-8")), mock.call(base_path + "/factor", "1".encode("utf-8")), mock.call(base_path + "/expected_load", "0".encode("utf-8")), ] @mock.patch("paasta_tools.autoscaling.load_boost.clusterman_metrics", autospec=True) @mock.patch( "paasta_tools.autoscaling.load_boost.load_system_paasta_config", autospec=True ) @freeze_time(TEST_CURRENT_TIME) def test_send_clusterman_metrics( mock_load_system_paasta_config, mock_clusterman_metrics ): fake_region = "westeros-1" fake_pool = "default" base_path = load_boost.get_zk_cluster_boost_path(fake_region, fake_pool) mock_load_system_paasta_config.return_value.get_cluster.return_value = ( "westeros-prod" ) mock_clusterman_metrics.generate_key_with_dimensions = ( lambda key, dims: f"{key}|{dims}" ) mock_writer = ( mock_clusterman_metrics.ClustermanMetricsBotoClient().get_writer().__enter__() ) with patch_zk_client(): load_boost.set_boost_factor( zk_boost_path=base_path, region=fake_region, pool=fake_pool, factor=1.3, duration_minutes=10, ) expected_metrics_dimensions = {"cluster": "westeros-prod", "pool": "default"} expected_metrics_key = f"boost_factor|{expected_metrics_dimensions}" assert mock_writer.send.call_args_list == [ mock.call((expected_metrics_key, TEST_CURRENT_TIME.timestamp(), 1.3)), mock.call((expected_metrics_key, TEST_CURRENT_TIME.timestamp() + 10 * 60, 1.0)), ] "
" from __future__ import absolute_import from __future__ import division from __future__ import print_function import os import sys from absl.testing import absltest # This stanza exercises setting $TEST_RANDOMIZE_ORDERING_SEED *after* importing # the absltest library. if os.environ.get('LATE_SET_TEST_RANDOMIZE_ORDERING_SEED', ''): os.environ['TEST_RANDOMIZE_ORDERING_SEED'] = os.environ[ 'LATE_SET_TEST_RANDOMIZE_ORDERING_SEED'] class ClassA(absltest.TestCase): def test_a(self): sys.stderr.write('\nclass A test A\n') def test_b(self): sys.stderr.write('\nclass A test B\n') def test_c(self): sys.stderr.write('\nclass A test C\n') if __name__ == '__main__': absltest.main() "
" from flexx import app, ui class Red(ui.Widget): CSS = '.flx-Red { background: #ff0000;}' class Deep1(ui.Widget): # This was broken on Chrome earlier def init(self): with ui.VBox(): ui.Label(text='Widget in a vbox in a widget in a vbox') with ui.VBox(flex=1): with ui.Widget(flex=1): with ui.VBox(): ui.Label(text='---') Red(flex=1) class Deep2(ui.Widget): def init(self): with ui.VBox(): ui.Label(text='Widget in a vbox in a vbox in a vbox') with ui.VBox(flex=1): with ui.VBox(flex=1): ui.Label(text='---') Red(flex=1) class Deep3(ui.Widget): def init(self): with ui.VBox(): ui.Label(text='Widget in a vbox in a hbox in a vbox') with ui.HBox(flex=1): ui.Label(text='|||') with ui.VBox(flex=1): ui.Label(text='---') Red(flex=1) class Deep4(ui.Widget): def init(self): with ui.HBox(): ui.Label(text='Widget in a hbox in a widget in a hbox') with ui.HBox(flex=1): with ui.Widget(flex=1): with ui.HBox(): ui.Label(text='|||') Red(flex=1) class Deep5(ui.Widget): def init(self): with ui.HBox(): ui.Label(text='Widget in a hbox in a hbox in a hbox') with ui.HBox(flex=1): with ui.HBox(flex=1): ui.Label(text='|||') Red(flex=1) class Deep6(ui.Widget): def init(self): with ui.HBox(): ui.Label(text='Widget in a hbox in a vbox in a hbox') with ui.VBox(flex=1): ui.Label(text='---') with ui.HBox(flex=1): ui.Label(text='|||') Red(flex=1) class Deep(ui.Widget): def init(self): with ui.HFix(): with ui.HFix(): Deep1() Deep2() Deep3() with ui.VFix(): Deep4() Deep5() Deep6() if __name__ == '__main__': app.launch(Deep, 'app') app.run() "
" from ...common.interfaces import AbstractPlugin class Plugin(AbstractPlugin): SECTION = 'rcassert' def __init__(self, core, cfg, name): AbstractPlugin.__init__(self, core, cfg, name) self.ok_codes = [] self.fail_code = 10 @staticmethod def get_key(): return __file__ def get_available_options(self): return ["pass", "fail_code"] def configure(self): codes = self.get_option("pass", '').split(' ') for code in codes: if code: self.ok_codes.append(int(code)) self.fail_code = int(self.get_option("fail_code", self.fail_code)) def post_process(self, retcode): if not self.ok_codes: return retcode for code in self.ok_codes: self.log.debug("Comparing %s with %s codes", code, retcode) if code == int(retcode): self.log.info( "Exit code %s was changed to 0 by RCAssert plugin", code) return 0 self.log.info( "Changing exit code to %s because RCAssert pass list was unsatisfied", self.fail_code) return self.fail_code "
" import pandas as pd import pytz from qstrader.system.rebalance.rebalance import Rebalance class EndOfMonthRebalance(Rebalance): """ Generates a list of rebalance timestamps for pre- or post-market, for the final calendar day of the month between the starting and ending dates provided. All timestamps produced are set to UTC. Parameters ---------- start_dt : `pd.Timestamp` The starting datetime of the rebalance range. end_dt : `pd.Timestamp` The ending datetime of the rebalance range. pre_market : `Boolean`, optional Whether to carry out the rebalance at market open/close on the final day of the month. Defaults to False, i.e at market close. """ def __init__( self, start_dt, end_dt, pre_market=False ): self.start_dt = start_dt self.end_dt = end_dt self.market_time = self._set_market_time(pre_market) self.rebalances = self._generate_rebalances() def _set_market_time(self, pre_market): """ Determines whether to use market open or market close as the rebalance time. Parameters ---------- pre_market : `Boolean` Whether the rebalance is carried out at market open/close. Returns ------- `str` The time string used for Pandas timestamp construction. """ return "14:30:00" if pre_market else "21:00:00" def _generate_rebalances(self): """ Utilise the Pandas date_range method to create the appropriate list of rebalance timestamps. Returns ------- `List[pd.Timestamp]` The list of rebalance timestamps. """ rebalance_dates = pd.date_range( start=self.start_dt, end=self.end_dt, freq='BM' ) rebalance_times = [ pd.Timestamp( "%s %s" % (date, self.market_time), tz=pytz.utc ) for date in rebalance_dates ] return rebalance_times "
" import posixpath from absl import flags from perfkitbenchmarker.linux_packages import cuda_toolkit from perfkitbenchmarker.linux_packages import nvidia_driver FLAGS = flags.FLAGS flags.DEFINE_string('tf_cpu_pip_package', 'https://anaconda.org/intel/tensorflow/1.12.0/download/' 'tensorflow-1.12.0-cp27-cp27mu-linux_x86_64.whl', 'TensorFlow CPU pip package to install. By default, PKB ' 'will install an Intel-optimized CPU build when using ' 'CPUs.') flags.DEFINE_string('tf_gpu_pip_package', 'tensorflow-gpu==1.12.0', 'TensorFlow GPU pip package to install. By default, PKB ' 'will install tensorflow-gpu==1.12 when using GPUs.') flags.DEFINE_string( 't2t_pip_package', 'tensor2tensor==1.7', 'Tensor2Tensor pip package to install. By default, PKB ' 'will install tensor2tensor==1.7 .') flags.DEFINE_string('tf_cnn_benchmarks_branch', 'cnn_tf_v1.12_compatible', 'TensorFlow CNN branchmarks branch that is compatible with ' 'A TensorFlow version.') NCCL_URL = 'https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb' NCCL_PACKAGE = 'nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb' def GetEnvironmentVars(vm): """Return a string containing TensorFlow-related environment variables. Args: vm: vm to get environment varibles Returns: string of environment variables """ env_vars = [] if nvidia_driver.CheckNvidiaGpuExists(vm): output, _ = vm.RemoteCommand('getconf LONG_BIT', should_log=True) long_bit = output.strip() lib_name = 'lib' if long_bit == '32' else 'lib64' env_vars.extend([ 'PATH=%s${PATH:+:${PATH}}' % posixpath.join(cuda_toolkit.CUDA_HOME, 'bin'), 'CUDA_HOME=%s' % cuda_toolkit.CUDA_HOME, 'LD_LIBRARY_PATH=%s${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}' % posixpath.join(cuda_toolkit.CUDA_HOME, lib_name)]) if FLAGS.aws_s3_region: env_vars.append('AWS_REGION={}'.format(FLAGS.aws_s3_region)) return ' '.join(env_vars) def GetTensorFlowVersion(vm): """Returns the version of tensorflow installed on the vm. Args: vm: the target vm on which to check the tensorflow version Returns: installed python tensorflow version as a string """ stdout, _ = vm.RemoteCommand( ('echo -e "import tensorflow\nprint(tensorflow.__version__)" | {0} python' .format(GetEnvironmentVars(vm))) ) return stdout.strip() def Install(vm): """Installs TensorFlow on the VM.""" has_gpu = nvidia_driver.CheckNvidiaGpuExists(vm) tf_pip_package = (FLAGS.tf_gpu_pip_package if has_gpu else FLAGS.tf_cpu_pip_package) if has_gpu: vm.Install('cuda_toolkit') vm.Install('nccl') vm.Install('cudnn') vm.Install('pip') vm.RemoteCommand('sudo pip install requests') vm.RemoteCommand('sudo pip install --upgrade absl-py') vm.RemoteCommand('sudo pip install --upgrade %s' % tf_pip_package, should_log=True) vm.RemoteCommand( 'sudo pip install --upgrade %s' % FLAGS.t2t_pip_package, should_log=True) vm.InstallPackages('git') _, _, retcode = vm.RemoteHostCommandWithReturnCode( 'test -d benchmarks', ignore_failure=True, suppress_warning=True) if retcode != 0: vm.RemoteCommand( 'git clone https://github.com/tensorflow/benchmarks.git', should_log=True) vm.RemoteCommand( 'cd benchmarks && git checkout {}'.format(FLAGS.tf_cnn_benchmarks_branch) ) if FLAGS.cloud == 'AWS' and FLAGS.tf_data_dir and ( not FLAGS.tf_use_local_data): vm.Install('aws_credentials') def Uninstall(vm): """Uninstalls TensorFlow on the VM.""" vm.RemoteCommand('sudo pip uninstall tensorflow', should_log=True) "
" from flexx import flx class Split(flx.Widget): def init(self): with flx.HSplit(): flx.Widget(style='background:#f00') with flx.VSplit(): flx.Widget(style='background:#0f0') with flx.HSplit(): flx.Widget(style='background:#ff0') with flx.VSplit(): flx.Widget(style='background:#f0f') with flx.HSplit(): flx.Widget(style='background:#0ff') flx.Widget(style='background:#00f') if __name__ == '__main__': m = flx.launch(Split) flx.run() "
" from datetime import timedelta import logging import voluptuous as vol from xboxapi import Client from homeassistant.components.sensor import PLATFORM_SCHEMA from homeassistant.const import CONF_API_KEY, CONF_SCAN_INTERVAL from homeassistant.core import callback import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity import Entity from homeassistant.helpers.event import async_track_time_interval _LOGGER = logging.getLogger(__name__) CONF_XUID = "xuid" ICON = "mdi:microsoft-xbox" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_API_KEY): cv.string, vol.Required(CONF_XUID): vol.All(cv.ensure_list, [cv.string]), } ) def setup_platform(hass, config, add_entities, discovery_info=None): """Set up the Xbox platform.""" api = Client(api_key=config[CONF_API_KEY]) entities = [] # request profile info to check api connection response = api.api_get("profile") if not response.ok: _LOGGER.error( "Can't setup X API connection. Check your account or " "api key on xapi.us. Code: %s Description: %s ", response.status_code, response.reason, ) return users = config[CONF_XUID] interval = timedelta(minutes=1 * len(users)) interval = config.get(CONF_SCAN_INTERVAL, interval) for xuid in users: gamercard = get_user_gamercard(api, xuid) if gamercard is None: continue entities.append(XboxSensor(api, xuid, gamercard, interval)) if entities: add_entities(entities, True) def get_user_gamercard(api, xuid): """Get profile info.""" gamercard = api.gamer(gamertag="", xuid=xuid).get("gamercard") _LOGGER.debug("User gamercard: %s", gamercard) if gamercard.get("success", True) and gamercard.get("code") is None: return gamercard _LOGGER.error( "Can't get user profile %s. Error Code: %s Description: %s", xuid, gamercard.get("code", "unknown"), gamercard.get("description", "unknown"), ) return None class XboxSensor(Entity): """A class for the Xbox account.""" def __init__(self, api, xuid, gamercard, interval): """Initialize the sensor.""" self._state = None self._presence = [] self._xuid = xuid self._api = api self._gamertag = gamercard["gamertag"] self._gamerscore = gamercard["gamerscore"] self._interval = interval self._picture = gamercard["gamerpicSmallSslImagePath"] self._tier = gamercard["tier"] @property def name(self): """Return the name of the sensor.""" return self._gamertag @property def should_poll(self): """Return False as this entity has custom polling.""" return False @property def state(self): """Return the state of the sensor.""" return self._state @property def device_state_attributes(self): """Return the state attributes.""" attributes = {"gamerscore": self._gamerscore, "tier": self._tier} for device in self._presence: for title in device["titles"]: attributes[f'{device["type"]} {title["placement"]}'] = title["name"] return attributes @property def entity_picture(self): """Avatar of the account.""" return self._picture @property def icon(self): """Return the icon to use in the frontend.""" return ICON async def async_added_to_hass(self): """Start custom polling.""" @callback def async_update(event_time=None): """Update the entity.""" self.async_schedule_update_ha_state(True) async_track_time_interval(self.hass, async_update, self._interval) def update(self): """Update state data from Xbox API.""" presence = self._api.gamer(gamertag="", xuid=self._xuid).get("presence") _LOGGER.debug("User presence: %s", presence) self._state = presence["state"] self._presence = presence.get("devices", []) "
" from homeassistant.components.websocket_api.const import TYPE_RESULT from homeassistant.const import HTTP_NOT_FOUND from homeassistant.helpers import intent async def test_add_item(hass, sl_setup): """Test adding an item intent.""" response = await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) assert response.speech["plain"]["speech"] == "I've added beer to your shopping list" async def test_recent_items_intent(hass, sl_setup): """Test recent items.""" await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "wine"}} ) await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "soda"}} ) response = await intent.async_handle(hass, "test", "HassShoppingListLastItems") assert ( response.speech["plain"]["speech"] == "These are the top 3 items on your shopping list: soda, wine, beer" ) async def test_deprecated_api_get_all(hass, hass_client, sl_setup): """Test the API.""" await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "wine"}} ) client = await hass_client() resp = await client.get("/api/shopping_list") assert resp.status == 200 data = await resp.json() assert len(data) == 2 assert data[0]["name"] == "beer" assert not data[0]["complete"] assert data[1]["name"] == "wine" assert not data[1]["complete"] async def test_ws_get_items(hass, hass_ws_client, sl_setup): """Test get shopping_list items websocket command.""" await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "wine"}} ) client = await hass_ws_client(hass) await client.send_json({"id": 5, "type": "shopping_list/items"}) msg = await client.receive_json() assert msg["success"] is True assert msg["id"] == 5 assert msg["type"] == TYPE_RESULT assert msg["success"] data = msg["result"] assert len(data) == 2 assert data[0]["name"] == "beer" assert not data[0]["complete"] assert data[1]["name"] == "wine" assert not data[1]["complete"] async def test_deprecated_api_update(hass, hass_client, sl_setup): """Test the API.""" await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "wine"}} ) beer_id = hass.data["shopping_list"].items[0]["id"] wine_id = hass.data["shopping_list"].items[1]["id"] client = await hass_client() resp = await client.post( f"/api/shopping_list/item/{beer_id}", json={"name": "soda"} ) assert resp.status == 200 data = await resp.json() assert data == {"id": beer_id, "name": "soda", "complete": False} resp = await client.post( f"/api/shopping_list/item/{wine_id}", json={"complete": True} ) assert resp.status == 200 data = await resp.json() assert data == {"id": wine_id, "name": "wine", "complete": True} beer, wine = hass.data["shopping_list"].items assert beer == {"id": beer_id, "name": "soda", "complete": False} assert wine == {"id": wine_id, "name": "wine", "complete": True} async def test_ws_update_item(hass, hass_ws_client, sl_setup): """Test update shopping_list item websocket command.""" await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "wine"}} ) beer_id = hass.data["shopping_list"].items[0]["id"] wine_id = hass.data["shopping_list"].items[1]["id"] client = await hass_ws_client(hass) await client.send_json( { "id": 5, "type": "shopping_list/items/update", "item_id": beer_id, "name": "soda", } ) msg = await client.receive_json() assert msg["success"] is True data = msg["result"] assert data == {"id": beer_id, "name": "soda", "complete": False} await client.send_json( { "id": 6, "type": "shopping_list/items/update", "item_id": wine_id, "complete": True, } ) msg = await client.receive_json() assert msg["success"] is True data = msg["result"] assert data == {"id": wine_id, "name": "wine", "complete": True} beer, wine = hass.data["shopping_list"].items assert beer == {"id": beer_id, "name": "soda", "complete": False} assert wine == {"id": wine_id, "name": "wine", "complete": True} async def test_api_update_fails(hass, hass_client, sl_setup): """Test the API.""" await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) client = await hass_client() resp = await client.post("/api/shopping_list/non_existing", json={"name": "soda"}) assert resp.status == HTTP_NOT_FOUND beer_id = hass.data["shopping_list"].items[0]["id"] resp = await client.post(f"/api/shopping_list/item/{beer_id}", json={"name": 123}) assert resp.status == 400 async def test_ws_update_item_fail(hass, hass_ws_client, sl_setup): """Test failure of update shopping_list item websocket command.""" await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) client = await hass_ws_client(hass) await client.send_json( { "id": 5, "type": "shopping_list/items/update", "item_id": "non_existing", "name": "soda", } ) msg = await client.receive_json() assert msg["success"] is False data = msg["error"] assert data == {"code": "item_not_found", "message": "Item not found"} await client.send_json({"id": 6, "type": "shopping_list/items/update", "name": 123}) msg = await client.receive_json() assert msg["success"] is False async def test_deprecated_api_clear_completed(hass, hass_client, sl_setup): """Test the API.""" await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "wine"}} ) beer_id = hass.data["shopping_list"].items[0]["id"] wine_id = hass.data["shopping_list"].items[1]["id"] client = await hass_client() # Mark beer as completed resp = await client.post( f"/api/shopping_list/item/{beer_id}", json={"complete": True} ) assert resp.status == 200 resp = await client.post("/api/shopping_list/clear_completed") assert resp.status == 200 items = hass.data["shopping_list"].items assert len(items) == 1 assert items[0] == {"id": wine_id, "name": "wine", "complete": False} async def test_ws_clear_items(hass, hass_ws_client, sl_setup): """Test clearing shopping_list items websocket command.""" await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "beer"}} ) await intent.async_handle( hass, "test", "HassShoppingListAddItem", {"item": {"value": "wine"}} ) beer_id = hass.data["shopping_list"].items[0]["id"] wine_id = hass.data["shopping_list"].items[1]["id"] client = await hass_ws_client(hass) await client.send_json( { "id": 5, "type": "shopping_list/items/update", "item_id": beer_id, "complete": True, } ) msg = await client.receive_json() assert msg["success"] is True await client.send_json({"id": 6, "type": "shopping_list/items/clear"}) msg = await client.receive_json() assert msg["success"] is True items = hass.data["shopping_list"].items assert len(items) == 1 assert items[0] == {"id": wine_id, "name": "wine", "complete": False} async def test_deprecated_api_create(hass, hass_client, sl_setup): """Test the API.""" client = await hass_client() resp = await client.post("/api/shopping_list/item", json={"name": "soda"}) assert resp.status == 200 data = await resp.json() assert data["name"] == "soda" assert data["complete"] is False items = hass.data["shopping_list"].items assert len(items) == 1 assert items[0]["name"] == "soda" assert items[0]["complete"] is False async def test_deprecated_api_create_fail(hass, hass_client, sl_setup): """Test the API.""" client = await hass_client() resp = await client.post("/api/shopping_list/item", json={"name": 1234}) assert resp.status == 400 assert len(hass.data["shopping_list"].items) == 0 async def test_ws_add_item(hass, hass_ws_client, sl_setup): """Test adding shopping_list item websocket command.""" client = await hass_ws_client(hass) await client.send_json({"id": 5, "type": "shopping_list/items/add", "name": "soda"}) msg = await client.receive_json() assert msg["success"] is True data = msg["result"] assert data["name"] == "soda" assert data["complete"] is False items = hass.data["shopping_list"].items assert len(items) == 1 assert items[0]["name"] == "soda" assert items[0]["complete"] is False async def test_ws_add_item_fail(hass, hass_ws_client, sl_setup): """Test adding shopping_list item failure websocket command.""" client = await hass_ws_client(hass) await client.send_json({"id": 5, "type": "shopping_list/items/add", "name": 123}) msg = await client.receive_json() assert msg["success"] is False assert len(hass.data["shopping_list"].items) == 0 "
" import quantities as pq from pylatex.quantities import _dimensionality_to_siunitx, Quantity def test_quantity(): v = 1 * pq.m/pq.s q1 = Quantity(v) assert q1.dumps() == r'\SI{1.0}{\meter\per\second}' q2 = Quantity(v, format_cb=lambda x: str(int(x))) assert q2.dumps() == r'\SI{1}{\meter\per\second}' q3 = Quantity(v, options={'zero-decimal-to-integer': 'true'}) ref = r'\SI[zero-decimal-to-integer=true]{1.0}{\meter\per\second}' assert q3.dumps() == ref def test_quantity_float(): q1 = Quantity(42.0) assert q1.dumps() == r'\num{42.0}' def test_quantity_uncertain(): t = pq.UncertainQuantity(7., pq.second, 1.) q1 = Quantity(t) assert q1.dumps() == r'\SI{7.0 +- 1.0}{\second}' def test_dimensionality_to_siunitx(): assert _dimensionality_to_siunitx((pq.volt/pq.kelvin).dimensionality) == \ r'\volt\per\Kelvin' if __name__ == '__main__': test_quantity() test_quantity_uncertain() test_dimensionality_to_siunitx() "
" import diamond.collector import os class NfsdCollector(diamond.collector.Collector): PROC = '/proc/net/rpc/nfsd' def get_default_config_help(self): config_help = super(NfsdCollector, self).get_default_config_help() config_help.update({ }) return config_help def get_default_config(self): """ Returns the default collector settings """ config = super(NfsdCollector, self).get_default_config() config.update({ 'path': 'nfsd' }) return config def collect(self): """ Collect stats """ if os.access(self.PROC, os.R_OK): results = {} # Open file file = open(self.PROC) for line in file: line = line.split() if line[0] == 'rc': results['reply_cache.hits'] = line[1] results['reply_cache.misses'] = line[2] results['reply_cache.nocache'] = line[3] elif line[0] == 'fh': results['filehandle.stale'] = line[1] results['filehandle.total-lookups'] = line[2] results['filehandle.anonlookups'] = line[3] results['filehandle.dir-not-in-cache'] = line[4] results['filehandle.nodir-not-in-cache'] = line[5] elif line[0] == 'io': results['input_output.bytes-read'] = line[1] results['input_output.bytes-written'] = line[2] elif line[0] == 'th': results['threads.threads'] = line[1] results['threads.fullcnt'] = line[2] results['threads.10-20-pct'] = line[3] results['threads.20-30-pct'] = line[4] results['threads.30-40-pct'] = line[5] results['threads.40-50-pct'] = line[6] results['threads.50-60-pct'] = line[7] results['threads.60-70-pct'] = line[8] results['threads.70-80-pct'] = line[9] results['threads.80-90-pct'] = line[10] results['threads.90-100-pct'] = line[11] results['threads.100-pct'] = line[12] elif line[0] == 'ra': results['read-ahead.cache-size'] = line[1] results['read-ahead.10-pct'] = line[2] results['read-ahead.20-pct'] = line[3] results['read-ahead.30-pct'] = line[4] results['read-ahead.40-pct'] = line[5] results['read-ahead.50-pct'] = line[6] results['read-ahead.60-pct'] = line[7] results['read-ahead.70-pct'] = line[8] results['read-ahead.80-pct'] = line[9] results['read-ahead.90-pct'] = line[10] results['read-ahead.100-pct'] = line[11] results['read-ahead.not-found'] = line[12] elif line[0] == 'net': results['net.cnt'] = line[1] results['net.udpcnt'] = line[2] results['net.tcpcnt'] = line[3] results['net.tcpconn'] = line[4] elif line[0] == 'rpc': results['rpc.cnt'] = line[1] results['rpc.badfmt'] = line[2] results['rpc.badauth'] = line[3] results['rpc.badclnt'] = line[4] elif line[0] == 'proc2': results['v2.unknown'] = line[1] results['v2.null'] = line[2] results['v2.getattr'] = line[3] results['v2.setattr'] = line[4] results['v2.root'] = line[5] results['v2.lookup'] = line[6] results['v2.readlink'] = line[7] results['v2.read'] = line[8] results['v2.wrcache'] = line[9] results['v2.write'] = line[10] results['v2.create'] = line[11] results['v2.remove'] = line[12] results['v2.rename'] = line[13] results['v2.link'] = line[14] results['v2.symlink'] = line[15] results['v2.mkdir'] = line[16] results['v2.rmdir'] = line[17] results['v2.readdir'] = line[18] results['v2.fsstat'] = line[19] elif line[0] == 'proc3': results['v3.unknown'] = line[1] results['v3.null'] = line[2] results['v3.getattr'] = line[3] results['v3.setattr'] = line[4] results['v3.lookup'] = line[5] results['v3.access'] = line[6] results['v3.readlink'] = line[7] results['v3.read'] = line[8] results['v3.write'] = line[9] results['v3.create'] = line[10] results['v3.mkdir'] = line[11] results['v3.symlink'] = line[12] results['v3.mknod'] = line[13] results['v3.remove'] = line[14] results['v3.rmdir'] = line[15] results['v3.rename'] = line[16] results['v3.link'] = line[17] results['v3.readdir'] = line[18] results['v3.readdirplus'] = line[19] results['v3.fsstat'] = line[20] results['v3.fsinfo'] = line[21] results['v3.pathconf'] = line[22] results['v3.commit'] = line[23] elif line[0] == 'proc4': results['v4.unknown'] = line[1] results['v4.null'] = line[2] results['v4.compound'] = line[3] elif line[0] == 'proc4ops': results['v4.ops.unknown'] = line[1] results['v4.ops.op0-unused'] = line[2] results['v4.ops.op1-unused'] = line[3] results['v4.ops.op2-future'] = line[4] results['v4.ops.access'] = line[5] results['v4.ops.close'] = line[6] results['v4.ops.commit'] = line[7] results['v4.ops.create'] = line[8] results['v4.ops.delegpurge'] = line[9] results['v4.ops.delegreturn'] = line[10] results['v4.ops.getattr'] = line[11] results['v4.ops.getfh'] = line[12] results['v4.ops.link'] = line[13] results['v4.ops.lock'] = line[14] results['v4.ops.lockt'] = line[15] results['v4.ops.locku'] = line[16] results['v4.ops.lookup'] = line[17] results['v4.ops.lookup_root'] = line[18] results['v4.ops.nverify'] = line[19] results['v4.ops.open'] = line[20] results['v4.ops.openattr'] = line[21] results['v4.ops.open_conf'] = line[22] results['v4.ops.open_dgrd'] = line[23] results['v4.ops.putfh'] = line[24] results['v4.ops.putpubfh'] = line[25] results['v4.ops.putrootfh'] = line[26] results['v4.ops.read'] = line[27] results['v4.ops.readdir'] = line[28] results['v4.ops.readlink'] = line[29] results['v4.ops.remove'] = line[30] results['v4.ops.rename'] = line[31] results['v4.ops.renew'] = line[32] results['v4.ops.restorefh'] = line[33] results['v4.ops.savefh'] = line[34] results['v4.ops.secinfo'] = line[35] results['v4.ops.setattr'] = line[36] results['v4.ops.setcltid'] = line[37] results['v4.ops.setcltidconf'] = line[38] results['v4.ops.verify'] = line[39] results['v4.ops.write'] = line[40] results['v4.ops.rellockowner'] = line[41] # Close File file.close() for stat in results.keys(): metric_name = '.' + stat metric_value = long(float(results[stat])) metric_value = self.derivative(metric_name, metric_value) self.publish(metric_name, metric_value, precision=3) return True return False "
YAML Metadata Warning: The task_categories "code-generation" is not in the official list: text-classification, token-classification, table-question-answering, question-answering, zero-shot-classification, translation, summarization, conversational, feature-extraction, text-generation, text2text-generation, fill-mask, sentence-similarity, text-to-speech, automatic-speech-recognition, audio-to-audio, audio-classification, voice-activity-detection, depth-estimation, image-classification, object-detection, image-segmentation, text-to-image, image-to-text, image-to-image, unconditional-image-generation, video-classification, reinforcement-learning, robotics, tabular-classification, tabular-regression, tabular-to-text, table-to-text, multiple-choice, text-retrieval, time-series-forecasting, visual-question-answering, document-question-answering, zero-shot-image-classification, graph-ml, other
YAML Metadata Warning: The task_categories "conditional-text-generation" is not in the official list: text-classification, token-classification, table-question-answering, question-answering, zero-shot-classification, translation, summarization, conversational, feature-extraction, text-generation, text2text-generation, fill-mask, sentence-similarity, text-to-speech, automatic-speech-recognition, audio-to-audio, audio-classification, voice-activity-detection, depth-estimation, image-classification, object-detection, image-segmentation, text-to-image, image-to-text, image-to-image, unconditional-image-generation, video-classification, reinforcement-learning, robotics, tabular-classification, tabular-regression, tabular-to-text, table-to-text, multiple-choice, text-retrieval, time-series-forecasting, visual-question-answering, document-question-answering, zero-shot-image-classification, graph-ml, other
YAML Metadata Warning: The task_ids "code-generation" is not in the official list: acceptability-classification, entity-linking-classification, fact-checking, intent-classification, multi-class-classification, multi-label-classification, multi-input-text-classification, natural-language-inference, semantic-similarity-classification, sentiment-classification, topic-classification, semantic-similarity-scoring, sentiment-scoring, sentiment-analysis, hate-speech-detection, text-scoring, named-entity-recognition, part-of-speech, parsing, lemmatization, word-sense-disambiguation, coreference-resolution, extractive-qa, open-domain-qa, closed-domain-qa, news-articles-summarization, news-articles-headline-generation, dialogue-generation, dialogue-modeling, language-modeling, text-simplification, explanation-generation, abstractive-qa, open-domain-abstractive-qa, closed-domain-qa, open-book-qa, closed-book-qa, slot-filling, masked-language-modeling, keyword-spotting, speaker-identification, audio-intent-classification, audio-emotion-recognition, audio-language-identification, multi-label-image-classification, multi-class-image-classification, face-detection, vehicle-detection, instance-segmentation, semantic-segmentation, panoptic-segmentation, image-captioning, grasping, task-planning, tabular-multi-class-classification, tabular-multi-label-classification, tabular-single-column-regression, rdf-to-text, multiple-choice-qa, multiple-choice-coreference-resolution, document-retrieval, utterance-retrieval, entity-linking-retrieval, fact-checking-retrieval, univariate-time-series-forecasting, multivariate-time-series-forecasting, visual-question-answering, document-question-answering

Dataset Card for notional-python

Dataset Summary

The Notional-python dataset contains python code files from 100 well-known repositories gathered from Google Bigquery Github Dataset. The dataset was created to test the ability of programming language models. Follow our repo to do the model evaluation using notional-python dataset.

Languages

Python

Dataset Creation

Curation Rationale

Notional-python was built to provide a dataset for testing the ability of the machine to generate python code.

Source Data

Initial Data Collection and Normalization

The data was obtained by filtering code from Google Bigquery Github data In order to improve the quality of the dataset, only python code files that meet the below conditions are added to the dataset:

  • Code with more than 60% of executable lines
  • Code with logic, not config files or comment-only files
  • Code with more than 30% of attribute declaration lines (E.G.: Some files contain just only class names and their class attributes, usually used for configuration of the project, these files were not selected)
  • Code without TODO and FIXME.

Who are the source language producers?

The producers are users of github.

Downloads last month
1
Edit dataset card
Evaluate models HF Leaderboard