input
stringlengths
11
5.29k
target
stringlengths
20
8.26k
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def setUpModule(): base.enabledPlugins.append('provenance') base.startServer()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def clone_results_repo(dest_dir): subprocess.check_call( ["git", "clone", "https://github.com/elopio/autopkgtest-results.git", dest_dir] )
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_make_gym_concat(name, num_envs, state_shape, reward_scale): seed = 0 frame_op = 'concat' # used for image, or for concat vector frame_op_len = 4 venv = make_gym_venv(name, num_envs, seed, frame_op=frame_op, frame_op_len=frame_op_len, reward_scale=reward_scale) venv.reset() for i in range(5): state, reward, done, info = venv.step([venv.action_space.sample()] * num_envs) assert isinstance(state, np.ndarray) stack_shape = (num_envs, frame_op_len * state_shape[0],) + state_shape[1:] assert state.shape == stack_shape assert isinstance(reward, np.ndarray) assert reward.shape == (num_envs,) assert isinstance(done, np.ndarray) assert done.shape == (num_envs,) assert len(info) == num_envs venv.close()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_make_gym_stack(name, num_envs, state_shape, reward_scale): seed = 0 frame_op = 'stack' # used for rnn frame_op_len = 4 venv = make_gym_venv(name, num_envs, seed, frame_op=frame_op, frame_op_len=frame_op_len, reward_scale=reward_scale) venv.reset() for i in range(5): state, reward, done, info = venv.step([venv.action_space.sample()] * num_envs) assert isinstance(state, np.ndarray) stack_shape = (num_envs, frame_op_len,) + state_shape assert state.shape == stack_shape assert isinstance(reward, np.ndarray) assert reward.shape == (num_envs,) assert isinstance(done, np.ndarray) assert done.shape == (num_envs,) assert len(info) == num_envs venv.close()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def initialize_options(self): self.install_dir = None self.force = 0 self.outfiles = []
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def finalize_options(self): self.set_undefined_options('install', ('install_headers', 'install_dir'), ('force', 'force'))
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def serialize(self): s = [] for v in self: if isinstance(v, BaseConfig): v = v.serialize() s.append(v) return s
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __init__(self, config_d, path=None, resolver=None): super().__init__(path=path, resolver=resolver) self._collection = {} for key, value in config_d.items(): self._collection[key] = self._from_python(key, value)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __getitem__(self, key): logger.debug("Get /%s config key", "/".join(self._path + (key,))) value = self._collection[key] return self._to_python(value)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def copy(self): return ConfigDict(self._collection.copy(), path=self._path, resolver=self._resolver)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def _update_changed_options(self): diff = Difference(self.want, self.have) updatables = Parameters.updatables changed = dict() for k in updatables: change = diff.compare(k) if change is None: continue else: if isinstance(change, dict): changed.update(change) else: changed[k] = change if changed: self.changes = UsableChanges(params=changed) return True return False
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __init__(self): self.supports_check_mode = True argument_spec = dict( pool=dict(required=True), key=dict(required=True, no_log=True), device=dict(required=True), managed=dict(type='bool'), device_port=dict(type='int', default=443), device_username=dict(no_log=True), device_password=dict(no_log=True), state=dict(default='present', choices=['absent', 'present']) ) self.argument_spec = {} self.argument_spec.update(f5_argument_spec) self.argument_spec.update(argument_spec) self.required_if = [ ['state', 'present', ['key', 'managed']], ['managed', False, ['device', 'device_username', 'device_password']], ['managed', True, ['device']] ]
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def main(): spec = ArgumentSpec() module = AnsibleModule( argument_spec=spec.argument_spec, supports_check_mode=spec.supports_check_mode, required_if=spec.required_if ) try: mm = ModuleManager(module=module) results = mm.exec_module() module.exit_json(**results) except F5ModuleError as ex: module.fail_json(msg=str(ex))
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def update_config(self) -> Optional[WebConfig]: if self.config_arg is None: return None config, web_config = parse_config(self.config_arg) self.cron_jobs = OrderedDict((job.name, job) for job in config) return web_config
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def job_should_run(startup: bool, job: JobConfig) -> bool: if ( startup and isinstance(job.schedule, str) and job.schedule == "@reboot" ): logger.debug( "Job %s (%s) is scheduled for startup (@reboot)", job.name, job.schedule_unparsed, ) return True elif isinstance(job.schedule, CronTab): crontab = job.schedule # type: CronTab if crontab.test(get_now(job.timezone).replace(second=0)): logger.debug( "Job %s (%s) is scheduled for now", job.name, job.schedule_unparsed, ) return True else: logger.debug( "Job %s (%s) not scheduled for now", job.name, job.schedule_unparsed, ) return False else: return False
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __init__(self, git_command): self.repo = LocalRepository(Env.get('app_dir'), command = git_command)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def enforce_required_arguments(module): ''' As many arguments are not required for autoscale group deletion they cannot be mandatory arguments for the module, so we enforce them here ''' missing_args = [] for arg in ('min_size', 'max_size', 'launch_config_name'): if module.params[arg] is None: missing_args.append(arg) if missing_args: module.fail_json(msg="Missing required arguments for autoscaling group create/update: %s" % ",".join(missing_args))
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def get_instances_by_lc(props, lc_check, initial_instances): new_instances = [] old_instances = [] # old instances are those that have the old launch config if lc_check: for i in props['instances']: if props['instance_facts'][i]['launch_config_name'] == props['launch_config_name']: new_instances.append(i) else: old_instances.append(i) else: log.debug("Comparing initial instances with current: {0}".format(initial_instances)) for i in props['instances']: if i not in initial_instances: new_instances.append(i) else: old_instances.append(i) log.debug("New instances: {0}, {1}".format(len(new_instances), new_instances)) log.debug("Old instances: {0}, {1}".format(len(old_instances), old_instances)) return new_instances, old_instances
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def _make_zone_cmds(self, themefile, state_name, boot=False): """ Given a theme file, return a list of zone commands.
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def initConfig(controllerObject): global controller controller = controllerObject logging.debug("Adding MySQL OpenStack configuration") paramsList = [ {"CMD_OPTION" : "mysql-host", "USAGE" : "The IP address of the server on which to install MySQL", "PROMPT" : "Enter the IP address of the MySQL server", "OPTION_LIST" : [], "VALIDATORS" : [validators.validate_ssh], "DEFAULT_VALUE" : utils.get_localhost_ip(), "MASK_INPUT" : False, "LOOSE_VALIDATION": True, "CONF_NAME" : "CONFIG_MYSQL_HOST", "USE_DEFAULT" : False, "NEED_CONFIRM" : False, "CONDITION" : False }, {"CMD_OPTION" : "mysql-user", "USAGE" : "Username for the MySQL admin user", "PROMPT" : "Enter the username for the MySQL admin user", "OPTION_LIST" : [], "VALIDATORS" : [validators.validate_not_empty], "DEFAULT_VALUE" : "root", "MASK_INPUT" : False, "LOOSE_VALIDATION": False, "CONF_NAME" : "CONFIG_MYSQL_USER", "USE_DEFAULT" : True, "NEED_CONFIRM" : False, "CONDITION" : False }, {"CMD_OPTION" : "mysql-pw", "USAGE" : "Password for the MySQL admin user", "PROMPT" : "Enter the password for the MySQL admin user", "OPTION_LIST" : [], "VALIDATORS" : [validators.validate_not_empty], "DEFAULT_VALUE" : uuid.uuid4().hex[:16], "MASK_INPUT" : True, "LOOSE_VALIDATION": True, "CONF_NAME" : "CONFIG_MYSQL_PW", "USE_DEFAULT" : False, "NEED_CONFIRM" : True, "CONDITION" : False }, ] groupDict = { "GROUP_NAME" : "MYSQL", "DESCRIPTION" : "MySQL Config parameters", "PRE_CONDITION" : lambda x: 'yes', "PRE_CONDITION_MATCH" : "yes", "POST_CONDITION" : False, "POST_CONDITION_MATCH" : True} controller.addGroup(groupDict, paramsList)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def initSequences(controller): mysqlsteps = [ {'title': 'Adding MySQL manifest entries', 'functions':[createmanifest]} ] controller.addSequence("Installing MySQL", [], [], mysqlsteps)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __init__(self, filenames_to_try=[]): # FUN FACT: In Python 3.2, they spontaneously changed the behaviour of # RawConfigParser so that it no longer considers ';' a comment delimiter # for inline comments. # # Compare: # "Configuration files may include comments, prefixed by specific # characters (# and ;). Comments may appear on their own in an otherwise # empty line, or may be entered in lines holding values or section names. # In the latter case, they need to be preceded by a whitespace character # to be recognized as a comment. (For backwards compatibility, only ; # starts an inline comment, while # does not.)" # -- https://docs.python.org/2/library/configparser.html # vs: # "Comment prefixes are strings that indicate the start of a valid comment # within a config file. comment_prefixes are used only on otherwise empty # lines (optionally indented) whereas inline_comment_prefixes can be used # after every valid value (e.g. section names, options and empty lines as # well). By default inline comments are disabled and '#' and ';' are used # as prefixes for whole line comments. # Changed in version 3.2: In previous versions of configparser behaviour # matched comment_prefixes=('#',';') and inline_comment_prefixes=(';',)." # -- https://docs.python.org/3/library/configparser.html#customizing-parser-behaviour # # Grrr... if sys.version_info.major >= 3: self._cp = RawConfigParser(dict_type=OrderedMultiDict, inline_comment_prefixes=(';',)) else: self._cp = RawConfigParser(dict_type=OrderedMultiDict) if isinstance(filenames_to_try, str): filenames_to_try = [filenames_to_try] self._filenames_to_try = filenames_to_try[:]
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def sections(self): return self._cp.sections()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def options(self, section_name): ## The client code doesn't need to check in advance that the requested ## section name is present in the config; this function will check ## this automatically, so no exception is raised by RawConfigParser. ## Check that `section_name` is present in the config. ## Otherwise, RawConfigParser will raise ConfigParser.NoSectionError. if not self._cp.has_section(section_name): return [] return self._cp.options(section_name)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def get(self, section_name, option_name, do_optionxform=True): if do_optionxform: # https://docs.python.org/2/library/configparser.html#ConfigParser.RawConfigParser.optionxform option_name = self._cp.optionxform(option_name) if section_name is None: return self._get_optval_in_sections(self.sections(), option_name) elif isinstance(section_name, str): return self._get_optval_in_sections([section_name], option_name) else: return self._get_optval_in_sections(section_name, option_name)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def _get_optval_in_sections(self, section_names, option_name): ## The client code doesn't need to check in advance that the requested ## section name(s) are present in the config; this function will check ## this automatically, so no exception is raised by RawConfigParser. optvals = [] for section_name in section_names: ## Check that `section_name` is present in the config. ## Otherwise, RawConfigParser will raise ConfigParser.NoSectionError. if not self._cp.has_section(section_name): continue optvals.extend([optval for optname, optval in self._cp.items(section_name) if optname == option_name]) return optvals
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def getboolean(self, section_name, option_name, do_optionxform=True): # https://docs.python.org/2/library/configparser.html#ConfigParser.RawConfigParser.getboolean return [self._coerce_to_boolean(optval) for optval in self.get(section_name, option_name, do_optionxform)]
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def configure(): cloud_host = JBoxCfg.get('cloud_host') JBoxGCD.INSTALLID = cloud_host['install_id'] JBoxGCD.REGION = cloud_host['region'] JBoxGCD.DOMAIN = cloud_host['domain']
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def domain(): if JBoxGCD.DOMAIN is None: JBoxGCD.configure() return JBoxGCD.DOMAIN
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def _evacuate(self, node=None, selector=None, pod_selector=None, dry_run=False, grace_period=None, force=False): ''' perform oadm manage-node evacuate ''' cmd = ['manage-node'] if node: cmd.extend(node) else: cmd.append('--selector={}'.format(selector)) if dry_run: cmd.append('--dry-run') if pod_selector: cmd.append('--pod-selector={}'.format(pod_selector)) if grace_period: cmd.append('--grace-period={}'.format(int(grace_period))) if force: cmd.append('--force') cmd.append('--evacuate') return self.openshift_cmd(cmd, oadm=True, output=True, output_type='raw')
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __init__(self, rname, namespace, kubeconfig, options): self.kubeconfig = kubeconfig self.name = rname self.namespace = namespace self._options = options
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def config_options(self): ''' return config options ''' return self._options
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __init__(self, content=None): ''' Constructor for deploymentconfig ''' if not content: content = DeploymentConfig.default_deployment_config super(DeploymentConfig, self).__init__(content=content)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def add_env_value(self, key, value): ''' add key, value pair to env array ''' rval = False env = self.get_env_vars() if env: env.append({'name': key, 'value': value}) rval = True else: result = self.put(DeploymentConfig.env_path, {'name': key, 'value': value}) rval = result[0] return rval
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def get_env_var(self, key): '''return a environment variables ''' results = self.get(DeploymentConfig.env_path) or [] if not results: return None for env_var in results: if env_var['name'] == key: return env_var return None
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def get_env_vars(self): '''return a environment variables ''' return self.get(DeploymentConfig.env_path) or []
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def update_env_var(self, key, value): '''place an env in the env var list''' env_vars_array = self.get_env_vars() idx = None for env_idx, env_var in enumerate(env_vars_array): if env_var['name'] == key: idx = env_idx break if idx: env_vars_array[idx]['value'] = value else: self.add_env_value(key, value) return True
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def get_replicas(self): ''' return replicas setting ''' return self.get(DeploymentConfig.replicas_path)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def add_volume_mount(self, volume_mount): ''' add a volume or volume mount to the proper location ''' exist_volume_mounts = self.get_volume_mounts() if not exist_volume_mounts and volume_mount: self.put(DeploymentConfig.volume_mounts_path, [volume_mount]) else: exist_volume_mounts.append(volume_mount)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def add_volume(self, volume): ''' add a volume or volume mount to the proper location ''' exist_volumes = self.get_volumes() if not volume: return if not exist_volumes: self.put(DeploymentConfig.volumes_path, [volume]) else: exist_volumes.append(volume)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def update_replicas(self, replicas): ''' update replicas value ''' self.put(DeploymentConfig.replicas_path, replicas)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __init__(self, sname, namespace, kubeconfig, secrets=None): ''' constructor for handling secret options ''' self.kubeconfig = kubeconfig self.name = sname self.namespace = namespace self.secrets = secrets self.data = {} self.create_dict()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __init__(self, registry_config, verbose=False): ''' Constructor for Registry a registry consists of 3 or more parts - dc/docker-registry - svc/docker-registry Parameters: :registry_config: :verbose: ''' super(Registry, self).__init__(registry_config.namespace, registry_config.kubeconfig, verbose) self.version = OCVersion(registry_config.kubeconfig, verbose) self.svc_ip = None self.portal_ip = None self.config = registry_config self.verbose = verbose self.registry_parts = [{'kind': 'dc', 'name': self.config.name}, {'kind': 'svc', 'name': self.config.name}, ] self.__prepared_registry = None self.volume_mounts = [] self.volumes = [] if self.config.config_options['volume_mounts']['value']: for volume in self.config.config_options['volume_mounts']['value']: volume_info = {'secret_name': volume.get('secret_name', None), 'name': volume.get('name', None), 'type': volume.get('type', None), 'path': volume.get('path', None), 'claimName': volume.get('claim_name', None), 'claimSize': volume.get('claim_size', None), } vol, vol_mount = Volume.create_volume_structure(volume_info) self.volumes.append(vol) self.volume_mounts.append(vol_mount) self.dconfig = None self.svc = None
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def deploymentconfig(self): ''' deploymentconfig property ''' return self.dconfig
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def deploymentconfig(self, config): ''' setter for deploymentconfig property ''' self.dconfig = config
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def service(self, config): ''' setter for service property ''' self.svc = config
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def prepared_registry(self, data): ''' setter method for prepared_registry attribute ''' self.__prepared_registry = data
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def get(self): ''' return the self.registry_parts ''' self.deploymentconfig = None self.service = None rval = 0 for part in self.registry_parts: result = self._get(part['kind'], name=part['name']) if result['returncode'] == 0 and part['kind'] == 'dc': self.deploymentconfig = DeploymentConfig(result['results'][0]) elif result['returncode'] == 0 and part['kind'] == 'svc': self.service = Service(result['results'][0]) if result['returncode'] != 0: rval = result['returncode'] return {'returncode': rval, 'deploymentconfig': self.deploymentconfig, 'service': self.service}
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def prepare_registry(self): ''' prepare a registry for instantiation ''' options = self.config.to_option_list(ascommalist='labels') cmd = ['registry'] cmd.extend(options) cmd.extend(['--dry-run=True', '-o', 'json']) results = self.openshift_cmd(cmd, oadm=True, output=True, output_type='json') # probably need to parse this # pylint thinks results is a string # pylint: disable=no-member if results['returncode'] != 0 and 'items' not in results['results']: raise RegistryException('Could not perform registry preparation. {}'.format(results)) service = None deploymentconfig = None # pylint: disable=invalid-sequence-index for res in results['results']['items']: if res['kind'] == 'DeploymentConfig': deploymentconfig = DeploymentConfig(res) elif res['kind'] == 'Service': service = Service(res) # Verify we got a service and a deploymentconfig if not service or not deploymentconfig: return results # results will need to get parsed here and modifications added deploymentconfig = DeploymentConfig(self.add_modifications(deploymentconfig)) # modify service ip if self.svc_ip: service.put('spec.clusterIP', self.svc_ip) if self.portal_ip: service.put('spec.portalIP', self.portal_ip) # the dry-run doesn't apply the selector correctly if self.service: service.put('spec.selector', self.service.get_selector()) # need to create the service and the deploymentconfig service_file = Utils.create_tmp_file_from_contents('service', service.yaml_dict) deployment_file = Utils.create_tmp_file_from_contents('deploymentconfig', deploymentconfig.yaml_dict) return {"service": service, "service_file": service_file, "service_update": False, "deployment": deploymentconfig, "deployment_file": deployment_file, "deployment_update": False}
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def create(self): '''Create a registry''' results = [] self.needs_update() # if the object is none, then we need to create it # if the object needs an update, then we should call replace # Handle the deploymentconfig if self.deploymentconfig is None: results.append(self._create(self.prepared_registry['deployment_file'])) elif self.prepared_registry['deployment_update']: results.append(self._replace(self.prepared_registry['deployment_file'])) # Handle the service if self.service is None: results.append(self._create(self.prepared_registry['service_file'])) elif self.prepared_registry['service_update']: results.append(self._replace(self.prepared_registry['service_file'])) # Clean up returned results rval = 0 for result in results: # pylint: disable=invalid-sequence-index if 'returncode' in result and result['returncode'] != 0: rval = result['returncode'] return {'returncode': rval, 'results': results}
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def add_modifications(self, deploymentconfig): ''' update a deployment config with changes ''' # The environment variable for REGISTRY_HTTP_SECRET is autogenerated # We should set the generated deploymentconfig to the in memory version # the following modifications will overwrite if needed if self.deploymentconfig: result = self.deploymentconfig.get_env_var('REGISTRY_HTTP_SECRET') if result: deploymentconfig.update_env_var('REGISTRY_HTTP_SECRET', result['value']) # Currently we know that our deployment of a registry requires a few extra modifications # Modification 1 # we need specific environment variables to be set for key, value in self.config.config_options['env_vars'].get('value', {}).items(): if not deploymentconfig.exists_env_key(key): deploymentconfig.add_env_value(key, value) else: deploymentconfig.update_env_var(key, value) # Modification 2 # we need specific volume variables to be set for volume in self.volumes: deploymentconfig.update_volume(volume) for vol_mount in self.volume_mounts: deploymentconfig.update_volume_mount(vol_mount) # Modification 3 # Edits edit_results = [] for edit in self.config.config_options['edits'].get('value', []): if edit['action'] == 'put': edit_results.append(deploymentconfig.put(edit['key'], edit['value'])) if edit['action'] == 'update': edit_results.append(deploymentconfig.update(edit['key'], edit['value'], edit.get('index', None), edit.get('curr_value', None))) if edit['action'] == 'append': edit_results.append(deploymentconfig.append(edit['key'], edit['value'])) if edit_results and not any([res[0] for res in edit_results]): return None return deploymentconfig.yaml_dict
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def needs_update(self): ''' check to see if we need to update ''' exclude_list = ['clusterIP', 'portalIP', 'type', 'protocol'] if self.service is None or \ not Utils.check_def_equal(self.prepared_registry['service'].yaml_dict, self.service.yaml_dict, exclude_list, debug=self.verbose): self.prepared_registry['service_update'] = True exclude_list = ['dnsPolicy', 'terminationGracePeriodSeconds', 'restartPolicy', 'timeoutSeconds', 'livenessProbe', 'readinessProbe', 'terminationMessagePath', 'securityContext', 'imagePullPolicy', 'protocol', # ports.portocol: TCP 'type', # strategy: {'type': 'rolling'} 'defaultMode', # added on secrets 'activeDeadlineSeconds', # added in 1.5 for timeouts ] if self.deploymentconfig is None or \ not Utils.check_def_equal(self.prepared_registry['deployment'].yaml_dict, self.deploymentconfig.yaml_dict, exclude_list, debug=self.verbose): self.prepared_registry['deployment_update'] = True return self.prepared_registry['deployment_update'] or self.prepared_registry['service_update'] or False
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def run_ansible(params, check_mode): '''run idempotent ansible code''' registry_options = {'images': {'value': params['images'], 'include': True}, 'latest_images': {'value': params['latest_images'], 'include': True}, 'labels': {'value': params['labels'], 'include': True}, 'ports': {'value': ','.join(params['ports']), 'include': True}, 'replicas': {'value': params['replicas'], 'include': True}, 'selector': {'value': params['selector'], 'include': True}, 'service_account': {'value': params['service_account'], 'include': True}, 'mount_host': {'value': params['mount_host'], 'include': True}, 'env_vars': {'value': params['env_vars'], 'include': False}, 'volume_mounts': {'value': params['volume_mounts'], 'include': False}, 'edits': {'value': params['edits'], 'include': False}, 'tls_key': {'value': params['tls_key'], 'include': True}, 'tls_certificate': {'value': params['tls_certificate'], 'include': True}, } # Do not always pass the daemonset and enforce-quota parameters because they are not understood # by old versions of oc. # Default value is false. So, it's safe to not pass an explicit false value to oc versions which # understand these parameters. if params['daemonset']: registry_options['daemonset'] = {'value': params['daemonset'], 'include': True} if params['enforce_quota']: registry_options['enforce_quota'] = {'value': params['enforce_quota'], 'include': True} rconfig = RegistryConfig(params['name'], params['namespace'], params['kubeconfig'], registry_options) ocregistry = Registry(rconfig, params['debug']) api_rval = ocregistry.get() state = params['state'] ######## # get ######## if state == 'list': if api_rval['returncode'] != 0: return {'failed': True, 'msg': api_rval} return {'changed': False, 'results': api_rval, 'state': state} ######## # Delete ######## if state == 'absent': if not ocregistry.exists(): return {'changed': False, 'state': state} if check_mode: return {'changed': True, 'msg': 'CHECK_MODE: Would have performed a delete.'} # Unsure as to why this is angry with the return type. # pylint: disable=redefined-variable-type api_rval = ocregistry.delete() if api_rval['returncode'] != 0: return {'failed': True, 'msg': api_rval} return {'changed': True, 'results': api_rval, 'state': state} if state == 'present': ######## # Create ######## if not ocregistry.exists(): if check_mode: return {'changed': True, 'msg': 'CHECK_MODE: Would have performed a create.'} api_rval = ocregistry.create() if api_rval['returncode'] != 0: return {'failed': True, 'msg': api_rval} return {'changed': True, 'results': api_rval, 'state': state} ######## # Update ######## if not params['force'] and not ocregistry.needs_update(): return {'changed': False, 'state': state} if check_mode: return {'changed': True, 'msg': 'CHECK_MODE: Would have performed an update.'} api_rval = ocregistry.update() if api_rval['returncode'] != 0: return {'failed': True, 'msg': api_rval} return {'changed': True, 'results': api_rval, 'state': state} return {'failed': True, 'msg': 'Unknown state passed. %s' % state}
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def main(): ''' ansible oc module for registry ''' module = AnsibleModule( argument_spec=dict( state=dict(default='present', type='str', choices=['present', 'absent']), debug=dict(default=False, type='bool'), namespace=dict(default='default', type='str'), name=dict(default=None, required=True, type='str'), kubeconfig=dict(default='/etc/origin/master/admin.kubeconfig', type='str'), images=dict(default=None, type='str'), latest_images=dict(default=False, type='bool'), labels=dict(default=None, type='dict'), ports=dict(default=['5000'], type='list'), replicas=dict(default=1, type='int'), selector=dict(default=None, type='str'), service_account=dict(default='registry', type='str'), mount_host=dict(default=None, type='str'), volume_mounts=dict(default=None, type='list'), env_vars=dict(default={}, type='dict'), edits=dict(default=[], type='list'), enforce_quota=dict(default=False, type='bool'), force=dict(default=False, type='bool'), daemonset=dict(default=False, type='bool'), tls_key=dict(default=None, type='str'), tls_certificate=dict(default=None, type='str'), ), supports_check_mode=True, ) results = Registry.run_ansible(module.params, module.check_mode) if 'failed' in results: module.fail_json(**results) module.exit_json(**results)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def ansible_catalog_item(appliance, ansible_repository): cat_item = appliance.collections.catalog_items.create( appliance.collections.catalog_items.ANSIBLE_PLAYBOOK, fauxfactory.gen_alphanumeric(), fauxfactory.gen_alphanumeric(), display_in_catalog=True, provisioning={ "repository": ansible_repository.name, "playbook": "dump_all_variables.yml", "machine_credential": "CFME Default Credential", "create_new": True, "provisioning_dialog_name": fauxfactory.gen_alphanumeric() } ) yield cat_item cat_item.delete_if_exists()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def policy_for_testing(appliance, full_template_vm_modscope, provider, ansible_action): vm = full_template_vm_modscope policy = appliance.collections.policies.create( VMControlPolicy, fauxfactory.gen_alpha(), scope="fill_field(VM and Instance : Name, INCLUDES, {})".format(vm.name) ) policy.assign_actions_to_event("Tag Complete", [ansible_action.description]) policy_profile = appliance.collections.policy_profiles.create( fauxfactory.gen_alpha(), policies=[policy]) provider.assign_policy_profiles(policy_profile.description) yield if policy.exists: policy.assign_events() provider.unassign_policy_profiles(policy_profile.description) policy_profile.delete() policy.delete()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def ansible_credential(wait_for_ansible, appliance, full_template_modscope): credential = appliance.collections.ansible_credentials.create( fauxfactory.gen_alpha(), "Machine", username=credentials[full_template_modscope.creds]["username"], password=credentials[full_template_modscope.creds]["password"] ) yield credential credential.delete_if_exists()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def main(): module = AnsibleModule( argument_spec = dict( hostname = dict(required=True), username = dict(required=True), password = dict(required=True, no_log=True), settings = dict(required=False, type='dict'), parameter = dict( required = True, choices = ['ntp_client', 'clock', 'identity', 'logging', 'routerboard_settings'], type = 'str' ), state = dict( required = False, choices = ['present', 'absent'], type = 'str' ), ), supports_check_mode=True ) params = module.params if params['parameter'] == 'routerboard_settings': params['parameter'] = 'routerboard/settings' if params['parameter'] == 'ntp_client': params['parameter'] = 'ntp/client' clean_params(params['settings']) mt_obj = MikrotikIdempotent( hostname = params['hostname'], username = params['username'], password = params['password'], state = params['state'], desired_params = params['settings'], idempotent_param= None, api_path = '/system/' + params['parameter'], check_mode = module.check_mode ) mt_obj.sync_state() if mt_obj.failed: module.fail_json( msg = mt_obj.failed_msg ) elif mt_obj.changed: module.exit_json( failed=False, changed=True, msg=mt_obj.changed_msg, diff={ "prepared": { "old": mt_obj.old_params, "new": mt_obj.new_params, }}, ) else: module.exit_json( failed=False, changed=False, #msg='', msg=params['settings'], )
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def get( self, scope: str, policy_assignment_name: str, **kwargs: Any ) -> "_models.PolicyAssignment": """Gets a policy assignment. :param scope: The scope of the policy assignment. :type scope: str :param policy_assignment_name: The name of the policy assignment to get. :type policy_assignment_name: str :keyword callable cls: A custom type or function that will be passed the direct response :return: PolicyAssignment, or the result of cls(response) :rtype: ~azure.mgmt.resource.policy.v2016_12_01.models.PolicyAssignment :raises: ~azure.core.exceptions.HttpResponseError """ cls = kwargs.pop('cls', None) # type: ClsType["_models.PolicyAssignment"] error_map = { 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } error_map.update(kwargs.pop('error_map', {}))
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def build_config_var(beta=False, external=False): """ Create the configuration key which will be used to locate the base tiddlywiki file. """ base = 'base_tiddlywiki' if external: base += '_external' if beta: base += '_beta' return base
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def list_tiddlers(self, tiddlers): """ Override tiddlers.link so the location in noscript is to /tiddlers. """ http_host, _ = determine_host(self.environ) space_name = determine_space(self.environ, http_host) if space_name: recipe_name = determine_space_recipe(self.environ, space_name) if '/recipes/%s' % recipe_name in tiddlers.link: tiddlers.link = '/tiddlers' return WikiSerialization.list_tiddlers(self, tiddlers)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def printsetting(): u'''print setting from staging.vars and common.vars''' print(_settings)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def deploy_template_sample_a(): _deploy_template_sample_a(_settings.sample_template_vars.sample_a)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def set_env_latest_app_a(): u'''eg. search latest app type a instance and set fabric env.''' print('set_env_latest_app_a')
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def set_env_latest_app_b(): u'''eg. search latest app type b instance and set fabric env.''' print('set_env_latest_app_b')
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def setup_tutorial(self): """ Set up tutorial for pre-defined computing environments :return: """ if self.tutorial_setup is None: self.tutorial_setup = "submit-host" if self.tutorial_setup == "submit-host": self.sitename = "condorpool" elif self.tutorial_setup == "usc-hpcc": self.sitename = "usc-hpcc" self.config = "glite" self.compute_queue = "quick" # for running the whole workflow as mpi job self.properties["pegasus.job.aggregator"] = "mpiexec" elif self.tutorial_setup == "osg": self.sitename = "osg" self.os = "linux" if not yesno("Do you want to use Condor file transfers", "y"): self.staging_site = "isi_workflow" elif self.tutorial_setup == "xsede-bosco": self.sitename = "condorpool" elif self.tutorial_setup == "bw-glite": self.sitename = "bluewaters" self.config = "glite" self.compute_queue = "normal" elif self.tutorial_setup == "wrangler-glite": self.sitename = "wrangler" self.config = "glite" self.compute_queue = "normal" elif self.tutorial_setup == "titan-glite": self.sitename = "titan" self.config = "glite" self.compute_queue = "titan" elif self.tutorial_setup == "summit-kub-bosco": self.sitename = "summit" self.config = "bosco" self.compute_queue = "batch" return
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def _try_run_local_init_op(self, sess): """Tries to run _local_init_op, if not None, and is ready for local init. Args: sess: A `Session`. Returns: A tuple (is_successful, msg), where is_successful is True if _local_init_op is None, or we ran _local_init_op, and False otherwise; and msg is a `String` with the reason why the model was not ready to run local init. """ if self._local_init_op is not None: is_ready_for_local_init, msg = self._model_ready_for_local_init(sess) if is_ready_for_local_init: logging.info("Running local_init_op.") sess.run(self._local_init_op, feed_dict=self._local_init_feed_dict, options=self._local_init_run_options) logging.info("Done running local_init_op.") return True, None else: return False, msg return True, None
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def testDropoutWrapperWithKerasLSTMCell(self): wrapper_cls = rnn_cell_wrapper_v2.DropoutWrapper cell = layers.LSTMCell(10) with self.assertRaisesRegex(ValueError, "does not work with "): wrapper_cls(cell) cell = layers.LSTMCellV2(10) with self.assertRaisesRegex(ValueError, "does not work with "): wrapper_cls(cell)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_cannot_write_empty_identifier(self): with self.assertRaises(ValueError): _ = cypher_escape("")
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def start(self, action_name: str) -> None: raise NotImplementedError
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def stop(self, action_name: str) -> None: raise NotImplementedError
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def remove(self): if self.client.check_mode: return True self.remove_from_device() if self.exists(): raise F5ModuleError("Failed to delete the license pool") return True
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
async def get_user_language(self, obj): """ You need to override this method and return user language """ raise NotImplementedError
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_config_errors(self): Session = scoped_session(sa.orm.sessionmaker()) s = Session() # noqa assert_raises_message( sa.exc.InvalidRequestError, "Scoped session is already present", Session, bind=testing.db, ) assert_warns_message( sa.exc.SAWarning, "At least one scoped session is already present. ", Session.configure, bind=testing.db, )
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_base_class_accept_raises_error(self): with self.assertRaisesRegex( NotImplementedError, 'Subclasses of BaseSuggestion should implement accept.'): self.base_suggestion.accept()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_base_class_pre_accept_validate_raises_error(self): with self.assertRaisesRegex( NotImplementedError, 'Subclasses of BaseSuggestion should implement' ' pre_accept_validate.'): self.base_suggestion.pre_accept_validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_base_class_populate_old_value_of_change_raises_error(self): with self.assertRaisesRegex( NotImplementedError, 'Subclasses of BaseSuggestion should implement' ' populate_old_value_of_change.'): self.base_suggestion.populate_old_value_of_change()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_base_class_pre_update_validate_raises_error(self): with self.assertRaisesRegex( NotImplementedError, 'Subclasses of BaseSuggestion should implement' ' pre_update_validate.'): self.base_suggestion.pre_update_validate({})
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_base_class_get_target_entity_html_strings(self): with self.assertRaisesRegex( NotImplementedError, 'Subclasses of BaseSuggestion should implement' ' get_target_entity_html_strings.'): self.base_suggestion.get_target_entity_html_strings()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_base_class_init_raises_error(self): with self.assertRaisesRegex( NotImplementedError, 'Subclasses of BaseVoiceoverApplication should implement ' '__init__.'): suggestion_registry.BaseVoiceoverApplication()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_base_class_accept_raises_error(self): with self.assertRaisesRegex( NotImplementedError, 'Subclasses of BaseVoiceoverApplication should implement accept.'): self.base_voiceover_application.accept()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_base_class_reject_raises_error(self): with self.assertRaisesRegex( NotImplementedError, 'Subclasses of BaseVoiceoverApplication should implement reject.'): self.base_voiceover_application.reject()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_with_invalid_target_type_raise_exception(self): self.voiceover_application.validate() self.voiceover_application.target_type = 'invalid_target' with self.assertRaisesRegex( utils.ValidationError, 'Expected target_type to be among allowed choices, ' 'received invalid_target' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_with_invalid_target_id_raise_exception(self): self.voiceover_application.validate() self.voiceover_application.target_id = 123 with self.assertRaisesRegex( utils.ValidationError, 'Expected target_id to be a string' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_with_invalid_status_raise_exception(self): self.voiceover_application.validate() self.voiceover_application.status = 'invalid_status' with self.assertRaisesRegex( utils.ValidationError, 'Expected status to be among allowed choices, ' 'received invalid_status' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_with_invalid_author_id_raise_exception(self): self.voiceover_application.validate() self.voiceover_application.author_id = 123 with self.assertRaisesRegex( utils.ValidationError, 'Expected author_id to be a string' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_with_invalid_final_reviewer_id_raise_exception(self): self.assertEqual( self.voiceover_application.status, suggestion_models.STATUS_IN_REVIEW) self.assertEqual(self.voiceover_application.final_reviewer_id, None) self.voiceover_application.validate() self.voiceover_application.final_reviewer_id = 123 with self.assertRaisesRegex( utils.ValidationError, 'Expected final_reviewer_id to be None as the ' 'voiceover application is not yet handled.' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_for_handled_application_with_invalid_final_review(self): self.assertEqual( self.voiceover_application.status, suggestion_models.STATUS_IN_REVIEW) self.assertEqual(self.voiceover_application.final_reviewer_id, None) self.voiceover_application.validate() self.voiceover_application.status = suggestion_models.STATUS_ACCEPTED with self.assertRaisesRegex( utils.ValidationError, 'Expected final_reviewer_id to be a string' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_for_rejected_application_with_no_message(self): self.assertEqual( self.voiceover_application.status, suggestion_models.STATUS_IN_REVIEW) self.assertEqual(self.voiceover_application.rejection_message, None) self.voiceover_application.validate() self.voiceover_application.final_reviewer_id = 'reviewer_id' self.voiceover_application.status = suggestion_models.STATUS_REJECTED with self.assertRaisesRegex( utils.ValidationError, 'Expected rejection_message to be a string for a ' 'rejected application' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_for_accepted_application_with_message(self): self.assertEqual( self.voiceover_application.status, suggestion_models.STATUS_IN_REVIEW) self.assertEqual(self.voiceover_application.rejection_message, None) self.voiceover_application.validate() self.voiceover_application.final_reviewer_id = 'reviewer_id' self.voiceover_application.status = suggestion_models.STATUS_ACCEPTED self.voiceover_application.rejection_message = 'Invalid message' with self.assertRaisesRegex( utils.ValidationError, 'Expected rejection_message to be None for the accepted ' 'voiceover application, received Invalid message' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_with_invalid_language_code_type_raise_exception(self): self.assertEqual(self.voiceover_application.language_code, 'en') self.voiceover_application.validate() self.voiceover_application.language_code = 1 with self.assertRaisesRegex( utils.ValidationError, 'Expected language_code to be a string' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_with_invalid_language_code_raise_exception(self): self.assertEqual(self.voiceover_application.language_code, 'en') self.voiceover_application.validate() self.voiceover_application.language_code = 'invalid language' with self.assertRaisesRegex( utils.ValidationError, 'Invalid language_code: invalid language' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_with_invalid_filename_type_raise_exception(self): self.assertEqual(self.voiceover_application.filename, 'audio_file.mp3') self.voiceover_application.validate() self.voiceover_application.filename = 1 with self.assertRaisesRegex( utils.ValidationError, 'Expected filename to be a string' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_validation_with_invalid_content_type_raise_exception(self): self.assertEqual(self.voiceover_application.content, '<p>Content</p>') self.voiceover_application.validate() self.voiceover_application.content = 1 with self.assertRaisesRegex( utils.ValidationError, 'Expected content to be a string' ): self.voiceover_application.validate()
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_to_dict_returns_correct_dict(self): self.voiceover_application.accept(self.reviewer_id) expected_dict = { 'voiceover_application_id': 'application_id', 'target_type': 'exploration', 'target_id': 'exp_id', 'status': 'accepted', 'author_name': 'author', 'final_reviewer_name': 'reviewer', 'language_code': 'en', 'content': '<p>Content</p>', 'filename': 'audio_file.mp3', 'rejection_message': None } self.assertEqual( self.voiceover_application.to_dict(), expected_dict)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_is_handled_property_returns_correct_value(self): self.assertFalse(self.voiceover_application.is_handled) self.voiceover_application.accept(self.reviewer_id) self.assertTrue(self.voiceover_application.is_handled)
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_accept_voiceover_application(self): self.assertEqual(self.voiceover_application.final_reviewer_id, None) self.assertEqual(self.voiceover_application.status, 'review') self.voiceover_application.accept(self.reviewer_id) self.assertEqual( self.voiceover_application.final_reviewer_id, self.reviewer_id) self.assertEqual(self.voiceover_application.status, 'accepted')
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_reject_voiceover_application(self): self.assertEqual(self.voiceover_application.final_reviewer_id, None) self.assertEqual(self.voiceover_application.status, 'review') self.voiceover_application.reject(self.reviewer_id, 'rejection message') self.assertEqual( self.voiceover_application.final_reviewer_id, self.reviewer_id) self.assertEqual(self.voiceover_application.status, 'rejected') self.assertEqual( self.voiceover_application.rejection_message, 'rejection message')
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def __repr__(self): return "<nevermatcher>"
def __init__(self): self.filediff = None meldsettings.connect('changed', self.on_setting_changed)
def test_exceptions(self): self.assert_(issubclass(DeoptionError, TypeError)) self.assertRaises(TypeError, lambda: Optional() ) self.assertRaises(TypeError, lambda: Optional(NotPassed, NotPassed) )