Datasets:
Sheerio
/
code_search_net_process

Dataset card Data Studio Files
xet
Community
1
code
stringlengths
1
18.2k
def random_string(length=6): """Create a random 6 character string. note: in case you use this function in a test during test together with an awsclient then this function is altered so you get reproducible results that will work with your recorded placebo json files (see helpers_aws.py). """ return ''.join([random.choice(string.ascii_lowercase) for i in range(length)])
def all_pages(method, request, accessor, cond=None): """Helper to process all pages using botocore service methods (exhausts NextToken). note: `cond` is optional... you can use it to make filtering more explicit if you like. Alternatively you can do the filtering in the `accessor` which is perfectly fine, too Note: lambda uses a slightly different mechanism so there is a specific version in ramuda_utils. :param method: service
method :param request: request dictionary for service call :param accessor: function to extract data from each response :param cond: filter function to return True / False based on a response :return: list of collected resources """ if cond is None: cond = lambda x: True result = [] next_token = None while True: if next_token: request['nextToken'] = next_token response = method(**request) if cond(response): data
= accessor(response) if data: if isinstance(data, list): result.extend(data) else: result.append(data) if 'nextToken' not in response: break next_token = response['nextToken'] return result
def get_invoke(command): """ Get the Cmd main method from the click command :param command: The click Command object :return: the do_* method for Cmd :rtype: function """ assert isinstance(command, click.Command) def invoke_(self, arg): # pylint: disable=unused-argument try: command.main(args=shlex.split(arg), prog_name=command.name, standalone_mode=False, parent=self.ctx) except click.ClickException as e: # Show the error message e.show() except click.Abort: # We got an EOF or Keyboard interrupt. Just silence it
pass except SystemExit: # Catch this an return the code instead. All of click's help commands do a sys.exit(), # and that's not ideal when running in a shell. pass except Exception as e: traceback.print_exception(type(e), e, None) logger.warning(traceback.format_exc()) # Always return False so the shell doesn't exit return False invoke_ = update_wrapper(invoke_, command.callback) invoke_.__name__ = 'do_%s' % command.name return invoke_
def get_help(command): """ Get the Cmd help function from the click command :param command: The click Command object :return: the help_* method for Cmd :rtype: function """ assert isinstance(command, click.Command) def help_(self): # pylint: disable=unused-argument extra = {} for key, value in command.context_settings.items(): if key not in extra: extra[key] = value # Print click's help message with click.Context(command, info_name=command.name, parent=self.ctx, **extra) as ctx: click.echo(ctx.get_help(),
color=ctx.color) help_.__name__ = 'help_%s' % command.name return help_
def get_complete(command): """ Get the Cmd complete function for the click command :param command: The click Command object :return: the complete_* method for Cmd :rtype: function """ assert isinstance(command, click.Command) def complete_(self, text, line, begidx, endidx): # pylint: disable=unused-argument # Parse the args args = shlex.split(line[:begidx]) # Strip of the first item which is the name of the command args = args[1:] # Then
pass them on to the get_choices method that click uses for completion return list(get_choices(command, command.name, args, text)) complete_.__name__ = 'complete_%s' % command.name return complete_
def load_template(): """Bail out if template is not found. """ cloudformation, found = load_cloudformation_template() if not found: print(colored.red('could not load cloudformation.py, bailing out...')) sys.exit(1) return cloudformation
def _import_public_names(module): "Import public names from module into this module, like import *" self = sys.modules[__name__] for name in module.__all__: if hasattr(self, name): # don't overwrite existing names continue setattr(self, name, getattr(module, name))
def create_argument_parser(): """Creates the argument parser for haas. """ parser = argparse.ArgumentParser(prog='haas') parser.add_argument('--version', action='version', version='%(prog)s {0}'.format(haas.__version__)) verbosity = parser.add_mutually_exclusive_group() verbosity.add_argument('-v', '--verbose', action='store_const', default=1, dest='verbosity', const=2, help='Verbose output') verbosity.add_argument('-q', '--quiet', action='store_const', const=0, dest='verbosity', help='Quiet output') parser.add_argument('-f', '--failfast', action='store_true', default=False, help='Stop on first fail or error') parser.add_argument('-c', '--catch', dest='catch_interrupt', action='store_true', default=False, help=('(Ignored) Catch ctrl-C and display results so ' 'far')) parser.add_argument('-b', '--buffer', action='store_true', default=False, help='Buffer stdout
and stderr during tests') parser.add_argument( 'start', nargs='*', default=[os.getcwd()], help=('One or more directories or dotted package/module names from ' 'which to start searching for tests')) parser.add_argument('-p', '--pattern', default='test*.py', help="Pattern to match tests ('test*.py' default)") parser.add_argument('-t', '--top-level-directory', default=None, help=('Top level directory of project (defaults to ' 'start directory)')) _add_log_level_option(parser) return parser
def run(self, plugin_manager=None): """Run the haas test runner. This will load and configure the selected plugins, set up the environment and begin test discovery, loading and running. Parameters ---------- plugin_manager : haas.plugin_manager.PluginManager [Optional] Override the use of the default plugin manager. """ if plugin_manager is None: plugin_manager = PluginManager() plugin_manager.add_plugin_arguments(self.parser) args = self.parser.parse_args(self.argv[1:]) environment_plugins = plugin_manager.get_enabled_hook_plugins( plugin_manager.ENVIRONMENT_HOOK, args) runner = plugin_manager.get_driver( plugin_manager.TEST_RUNNER, args) with
PluginContext(environment_plugins): loader = Loader() discoverer = plugin_manager.get_driver( plugin_manager.TEST_DISCOVERY, args, loader=loader) suites = [ discoverer.discover( start=start, top_level_directory=args.top_level_directory, pattern=args.pattern, ) for start in args.start ] if len(suites) == 1: suite = suites[0] else: suite = loader.create_suite(suites) test_count = suite.countTestCases() result_handlers = plugin_manager.get_enabled_hook_plugins( plugin_manager.RESULT_HANDLERS, args, test_count=test_count) result_collector = ResultCollector( buffer=args.buffer, failfast=args.failfast) for result_handler in result_handlers: result_collector.add_result_handler(result_handler) result = runner.run(result_collector, suite) return not result.wasSuccessful()
def encrypt_password(**kwargs): """ Crypt :new_value: if it's not crypted yet. """ new_value = kwargs['new_value'] field = kwargs['field'] min_length = field.params['min_length'] if len(new_value) < min_length: raise ValueError( '`{}`: Value length must be more than {}'.format( field.name, field.params['min_length'])) if new_value and not crypt.match(new_value): new_value = str(crypt.encode(new_value)) return new_value
def create_apikey_model(user_model): """ Generate ApiKey model class and connect it with :user_model:. ApiKey is generated with relationship to user model class :user_model: as a One-to-One relationship with a backreference. ApiKey is set up to be auto-generated when a new :user_model: is created. Returns ApiKey document class. If ApiKey is already defined, it is not generated. Arguments: :user_model: Class that represents user model for which
api keys will be generated and with which ApiKey will have relationship. """ try: return engine.get_document_cls('ApiKey') except ValueError: pass fk_kwargs = { 'ref_column': None, } if hasattr(user_model, '__tablename__'): fk_kwargs['ref_column'] = '.'.join([ user_model.__tablename__, user_model.pk_field()]) fk_kwargs['ref_column_type'] = user_model.pk_field_type() class ApiKey(engine.BaseDocument): __tablename__ = 'nefertari_apikey' id = engine.IdField(primary_key=True) token = engine.StringField(default=create_apikey_token) user = engine.Relationship( document=user_model.__name__, uselist=False, backref_name='api_key', backref_uselist=False) user_id = engine.ForeignKeyField( ref_document=user_model.__name__, **fk_kwargs) def reset_token(self): self.update({'token': create_apikey_token()}) return
self.token # Setup ApiKey autogeneration on :user_model: creation ApiKey.autogenerate_for(user_model, 'user') return ApiKey
def cache_request_user(user_cls, request, user_id): """ Helper function to cache currently logged in user. User is cached at `request._user`. Caching happens only only if user is not already cached or if cached user's pk does not match `user_id`. :param user_cls: User model class to use for user lookup. :param request: Pyramid Request instance. :user_id: Current user primary key field value. """ pk_field = user_cls.pk_field() user
= getattr(request, '_user', None) if user is None or getattr(user, pk_field, None) != user_id: request._user = user_cls.get_item(**{pk_field: user_id})
def get_token_credentials(cls, username, request): """ Get api token for user with username of :username: Used by Token-based auth as `credentials_callback` kwarg. """ try: user = cls.get_item(username=username) except Exception as ex: log.error(str(ex)) forget(request) else: if user: return user.api_key.token
def get_groups_by_token(cls, username, token, request): """ Get user's groups if user with :username: exists and their api key token equals :token: Used by Token-based authentication as `check` kwarg. """ try: user = cls.get_item(username=username) except Exception as ex: log.error(str(ex)) forget(request) return else: if user and user.api_key.token == token: return ['g:%s' % g for g in user.groups]
def authenticate_by_password(cls, params): """ Authenticate user with login and password from :params: Used both by Token and Ticket-based auths (called from views). """ def verify_password(user, password): return crypt.check(user.password, password) success = False user = None login = params['login'].lower().strip() key = 'email' if '@' in login else 'username' try: user = cls.get_item(**{key: login}) except Exception as ex: log.error(str(ex)) if user: password = params.get('password', None) success
= (password and verify_password(user, password)) return success, user
def get_groups_by_userid(cls, userid, request): """ Return group identifiers of user with id :userid: Used by Ticket-based auth as `callback` kwarg. """ try: cache_request_user(cls, request, userid) except Exception as ex: log.error(str(ex)) forget(request) else: if request._user: return ['g:%s' % g for g in request._user.groups]
def create_account(cls, params): """ Create auth user instance with data from :params:. Used by both Token and Ticket-based auths to register a user ( called from views). """ user_params = dictset(params).subset( ['username', 'email', 'password']) try: return cls.get_or_create( email=user_params['email'], defaults=user_params) except JHTTPBadRequest: raise JHTTPBadRequest('Failed to create account.')
def get_authuser_by_userid(cls, request): """ Get user by ID. Used by Ticket-based auth. Is added as request method to populate `request.user`. """ userid = authenticated_userid(request) if userid: cache_request_user(cls, request, userid) return request._user
def get_authuser_by_name(cls, request): """ Get user by username Used by Token-based auth. Is added as request method to populate `request.user`. """ username = authenticated_userid(request) if username: return cls.get_item(username=username)
def walk(self): """ Walk the directory like os.path (yields a 3-tuple (dirpath, dirnames, filenames) except it exclude all files/directories on the fly. """ for root, dirs, files in os.walk(self.path, topdown=True): # TODO relative walk, recursive call if root excluder found??? #root_excluder = get_root_excluder(root) ndirs = [] # First we exclude directories for d in list(dirs): if self.is_excluded(os.path.join(root, d)): dirs.remove(d) elif not os.path.islink(os.path.join(root, d)): ndirs.append(d)
nfiles = [] for fpath in (os.path.join(root, f) for f in files): if not self.is_excluded(fpath) and not os.path.islink(fpath): nfiles.append(os.path.relpath(fpath, root)) yield root, ndirs, nfiles
def includeme(config): """ Set up event subscribers. """ from .models import ( AuthUserMixin, random_uuid, lower_strip, encrypt_password, ) add_proc = config.add_field_processors add_proc( [random_uuid, lower_strip], model=AuthUserMixin, field='username') add_proc([lower_strip], model=AuthUserMixin, field='email') add_proc([encrypt_password], model=AuthUserMixin, field='password')
def _make_request(self, method, params): """Make request to API endpoint Note: Ignoring SSL cert validation due to intermittent failures http://requests.readthedocs.org/en/latest/user/advanced/#ssl-cert-verification """ if self.blocked_until is not None and \ datetime.datetime.utcnow() < self.blocked_until: raise SlackError("Too many requests - wait until {0}" \ .format(self.blocked_until)) url = "%s/%s" % (SlackClient.BASE_URL, method) params['token'] = self.token response = requests.post(url, data=params, verify=self.verify) if response.status_code == 429: # Too many requests retry_after =
int(response.headers.get('retry-after', '1')) self.blocked_until = datetime.datetime.utcnow() + \ datetime.timedelta(seconds=retry_after) raise SlackError("Too many requests - retry after {0} second(s)" \ .format(retry_after)) result = response.json() if not result['ok']: raise SlackError(result['error']) return result
def channels_list(self, exclude_archived=True, **params): """channels.list This method returns a list of all channels in the team. This includes channels the caller is in, channels they are not currently in, and archived channels. The number of (non-deactivated) members in each channel is also returned. https://api.slack.com/methods/channels.list """ method = 'channels.list' params.update({'exclude_archived': exclude_archived and 1 or 0}) return self._make_request(method, params)
def channel_name_to_id(self, channel_name, force_lookup=False): """Helper name for getting a channel's id from its name """ if force_lookup or not self.channel_name_id_map: channels = self.channels_list()['channels'] self.channel_name_id_map = {channel['name']: channel['id'] for channel in channels} channel = channel_name.startswith('#') and channel_name[1:] or channel_name return self.channel_name_id_map.get(channel)
def chat_post_message(self, channel, text, **params): """chat.postMessage This method posts a message to a channel. https://api.slack.com/methods/chat.postMessage """ method = 'chat.postMessage' params.update({ 'channel': channel, 'text': text, }) return self._make_request(method, params)
def chat_update_message(self, channel, text, timestamp, **params): """chat.update This method updates a message. Required parameters: `channel`: Channel containing the message to be updated. (e.g: "C1234567890") `text`: New text for the message, using the default formatting rules. (e.g: "Hello world") `timestamp`: Timestamp of the message to be updated (e.g: "1405894322.002768") https://api.slack.com/methods/chat.update """ method = 'chat.update' if self._channel_is_name(channel): # chat.update only takes channel ids (not channel names)
channel = self.channel_name_to_id(channel) params.update({ 'channel': channel, 'text': text, 'ts': timestamp, }) return self._make_request(method, params)
def includeme(config): """ Connect view to route that catches all URIs like 'something,something,...' """ root = config.get_root_resource() root.add('nef_polymorphic', '{collections:.+,.+}', view=PolymorphicESView, factory=PolymorphicACL)
def get_collections(self): """ Get names of collections from request matchdict. :return: Names of collections :rtype: list of str """ collections = self.request.matchdict['collections'].split('/')[0] collections = [coll.strip() for coll in collections.split(',')] return set(collections)
def get_resources(self, collections): """ Get resources that correspond to values from :collections:. :param collections: Collection names for which resources should be gathered :type collections: list of str :return: Gathered resources :rtype: list of Resource instances """ res_map = self.request.registry._model_collections resources = [res for res in res_map.values() if res.collection_name in collections] resources = [res for res in resources if res] return set(resources)
def _get_least_permissions_aces(self, resources): """ Get ACEs with the least permissions that fit all resources. To have access to polymorph on N collections, user MUST have access to all of them. If this is true, ACEs are returned, that allows 'view' permissions to current request principals. Otherwise None is returned thus blocking all permissions except those defined in `nefertari.acl.BaseACL`. :param resources: :type resources: list of
Resource instances :return: Generated Pyramid ACEs or None :rtype: tuple or None """ factories = [res.view._factory for res in resources] contexts = [factory(self.request) for factory in factories] for ctx in contexts: if not self.request.has_permission('view', ctx): return else: return [ (Allow, principal, 'view') for principal in self.request.effective_principals ]
def set_collections_acl(self): """ Calculate and set ACL valid for requested collections. DENY_ALL is added to ACL to make sure no access rules are inherited. """ acl = [(Allow, 'g:admin', ALL_PERMISSIONS)] collections = self.get_collections() resources = self.get_resources(collections) aces = self._get_least_permissions_aces(resources) if aces is not None: for ace in aces: acl.append(ace) acl.append(DENY_ALL) self.__acl__ = tuple(acl)
def determine_types(self): """ Determine ES type names from request data. In particular `request.matchdict['collections']` is used to determine types names. Its value is comma-separated sequence of collection names under which views have been registered. """ from nefertari.elasticsearch import ES collections = self.get_collections() resources = self.get_resources(collections) models = set([res.view.Model for res in resources]) es_models = [mdl for mdl in models if mdl and getattr(mdl, '_index_enabled', False)]
types = [ES.src2type(mdl.__name__) for mdl in es_models] return types
def get_command(domain_name, command_name): """Returns a closure function that dispatches message to the WebSocket.""" def send_command(self, **kwargs): return self.ws.send_message( '{0}.{1}'.format(domain_name, command_name), kwargs ) return send_command
def DomainFactory(domain_name, cmds): """Dynamically create Domain class and set it's methods.""" klass = type(str(domain_name), (BaseDomain,), {}) for c in cmds: command = get_command(domain_name, c['name']) setattr(klass, c['name'], classmethod(command)) return klass
def main(): """The entrypoint for the hairball command installed via setup.py.""" description = ('PATH can be either the path to a scratch file, or a ' 'directory containing scratch files. Multiple PATH ' 'arguments can be provided.') parser = OptionParser(usage='%prog -p PLUGIN_NAME [options] PATH...', description=description, version='%prog {}'.format(__version__)) parser.add_option('-d', '--plugin-dir', metavar='DIR', help=('Specify the path to a directory containing ' 'plugins. Plugins in this directory take
' 'precedence over similarly named plugins ' 'included with Hairball.')) parser.add_option('-p', '--plugin', action='append', help=('Use the named plugin to perform analysis. ' 'This option can be provided multiple times.')) parser.add_option('-k', '--kurt-plugin', action='append', help=('Provide either a python import path (e.g, ' 'kelp.octopi) to a package/module, or the path' ' to a python file, which will be loaded as a ' 'Kurt plugin. This option can be
provided ' 'multiple times.')) parser.add_option('-q', '--quiet', action='store_true', help=('Prevent output from Hairball. Plugins may still ' 'produce output.')) parser.add_option('-C', '--no-cache', action='store_true', help='Do not use Hairball\'s cache.', default=False) options, args = parser.parse_args(sys.argv[1:]) if not options.plugin: parser.error('At least one plugin must be specified via -p.') if not args: parser.error('At least one PATH must be provided.') if options.plugin_dir: if os.path.isdir(options.plugin_dir): sys.path.append(options.plugin_dir) else: parser.error('{} is not a directory'.format(options.plugin_dir)) hairball
= Hairball(options, args, cache=not options.no_cache) hairball.initialize_plugins() hairball.process() hairball.finalize()
def path_to_key(filepath): """Return the sha1sum (key) belonging to the file at filepath.""" tmp, last = os.path.split(filepath) tmp, middle = os.path.split(tmp) return '{}{}{}'.format(os.path.basename(tmp), middle, os.path.splitext(last)[0])
def key_to_path(self, key): """Return the fullpath to the file with sha1sum key.""" return os.path.join(self.cache_dir, key[:2], key[2:4], key[4:] + '.pkl')
def load(self, filename): """Optimized load and return the parsed version of filename. Uses the on-disk parse cache if the file is located in it. """ # Compute sha1 hash (key) with open(filename) as fp: key = sha1(fp.read()).hexdigest() path = self.key_to_path(key) # Return the cached file if available if key in self.hashes: try: with open(path) as fp: return cPickle.load(fp) except EOFError: os.unlink(path) self.hashes.remove(key) except IOError:
self.hashes.remove(key) # Create the nested cache directory try: os.makedirs(os.path.dirname(path)) except OSError as exc: if exc.errno != errno.EEXIST: raise # Process the file and save in the cache scratch = kurt.Project.load(filename) # can fail with os.fdopen(os.open(path, os.O_WRONLY | os.O_CREAT, 0400), 'w') as fp: # open file for writing but make it immediately read-only cPickle.dump(scratch, fp, cPickle.HIGHEST_PROTOCOL) self.hashes.add(key) return scratch
def hairball_files(self, paths, extensions): """Yield filepath to files with the proper extension within paths.""" def add_file(filename): return os.path.splitext(filename)[1] in extensions while paths: arg_path = paths.pop(0) if os.path.isdir(arg_path): found = False for path, dirs, files in os.walk(arg_path): dirs.sort() # Traverse in sorted order for filename in sorted(files): if add_file(filename): yield os.path.join(path, filename) found = True if not found: if not self.options.quiet: print('No files found in
{}'.format(arg_path)) elif add_file(arg_path): yield arg_path elif not self.options.quiet: print('Invalid file {}'.format(arg_path)) print('Did you forget to load a Kurt plugin (-k)?')
def initialize_plugins(self): """Attempt to Load and initialize all the plugins. Any issues loading plugins will be output to stderr. """ for plugin_name in self.options.plugin: parts = plugin_name.split('.') if len(parts) > 1: module_name = '.'.join(parts[:-1]) class_name = parts[-1] else: # Use the titlecase format of the module name as the class name module_name = parts[0] class_name = parts[0].title() # First try to load plugins from
the passed in plugins_dir and then # from the hairball.plugins package. plugin = None for package in (None, 'hairball.plugins'): if package: module_name = '{}.{}'.format(package, module_name) try: module = __import__(module_name, fromlist=[class_name]) # Initializes the plugin by calling its constructor plugin = getattr(module, class_name)() # Verify plugin is of the correct class if not isinstance(plugin, HairballPlugin): sys.stderr.write('Invalid type for plugin {}: {}\n' .format(plugin_name, type(plugin))) plugin =
None else: break except (ImportError, AttributeError): pass if plugin: self.plugins.append(plugin) else: sys.stderr.write('Cannot find plugin {}\n'.format(plugin_name)) if not self.plugins: sys.stderr.write('No plugins loaded. Goodbye!\n') sys.exit(1)
def process(self): """Run the analysis across all files found in the given paths. Each file is loaded once and all plugins are run against it before loading the next file. """ for filename in self.hairball_files(self.paths, self.extensions): if not self.options.quiet: print(filename) try: if self.cache: scratch = self.cache.load(filename) else: scratch = kurt.Project.load(filename) except Exception: # pylint: disable=W0703 traceback.print_exc() continue for plugin in self.plugins: # pylint: disable=W0212
plugin._process(scratch, filename=filename)
def maybe_dotted(module, throw=True): """ If ``module`` is a dotted string pointing to the module, imports and returns the module object. """ try: return Configurator().maybe_dotted(module) except ImportError as e: err = '%s not found. %s' % (module, e) if throw: raise ImportError(err) else: log.error(err) return None
def issequence(arg): """Return True if `arg` acts as a list and does not look like a string.""" string_behaviour = ( isinstance(arg, six.string_types) or isinstance(arg, six.text_type)) list_behaviour = hasattr(arg, '__getitem__') or hasattr(arg, '__iter__') return not string_behaviour and list_behaviour
def merge_dicts(a, b, path=None): """ Merge dict :b: into dict :a: Code snippet from http://stackoverflow.com/a/7205107 """ if path is None: path = [] for key in b: if key in a: if isinstance(a[key], dict) and isinstance(b[key], dict): merge_dicts(a[key], b[key], path + [str(key)]) elif a[key] == b[key]: pass # same leaf value else: raise Exception( 'Conflict at %s' % '.'.join(path + [str(key)])) else: a[key] =
b[key] return a
def str2dict(dotted_str, value=None, separator='.'): """ Convert dotted string to dict splitting by :separator: """ dict_ = {} parts = dotted_str.split(separator) d, prev = dict_, None for part in parts: prev = d d = d.setdefault(part, {}) else: if value is not None: prev[part] = value return dict_
def validate_data_privacy(request, data, wrapper_kw=None): """ Validate :data: contains only data allowed by privacy settings. :param request: Pyramid Request instance :param data: Dict containing request/response data which should be validated """ from nefertari import wrappers if wrapper_kw is None: wrapper_kw = {} wrapper = wrappers.apply_privacy(request) allowed_fields = wrapper(result=data, **wrapper_kw).keys() data = data.copy() data.pop('_type', None) not_allowed_fields = set(data.keys()) - set(allowed_fields) if not_allowed_fields: raise wrappers.ValidationError(', '.join(not_allowed_fields))
def drop_reserved_params(params): """ Drops reserved params """ from nefertari import RESERVED_PARAMS params = params.copy() for reserved_param in RESERVED_PARAMS: if reserved_param in params: params.pop(reserved_param) return params
def _send_command_raw(self, command, opt=''): """ Description: The TV doesn't handle long running connections very well, so we open a new connection every time. There might be a better way to do this, but it's pretty quick and resilient. Returns: If a value is being requested ( opt2 is "?" ), then the return value is returned. If a value is being set, it returns
True for "OK" or False for "ERR" """ # According to the documentation: # http://files.sharpusa.com/Downloads/ForHome/ # HomeEntertainment/LCDTVs/Manuals/tel_man_LC40_46_52_60LE830U.pdf # Page 58 - Communication conditions for IP # The connection could be lost (but not only after 3 minutes), # so we need to the remote commands to be sure about states end_time = time.time() + self.timeout while time.time() < end_time: try: # Connect sock_con =
socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock_con.settimeout(self.connection_timeout) sock_con.connect((self.ip_address, self.port)) # Authenticate sock_con.send(self.auth) sock_con.recv(1024) sock_con.recv(1024) # Send command if opt != '': command += str(opt) sock_con.send(str.encode(command.ljust(8) + '\r')) status = bytes.decode(sock_con.recv(1024)).strip() except (OSError, socket.error) as exp: time.sleep(0.1) if time.time() >= end_time: raise exp else: sock_con.close() # Sometimes the status is empty so # We need to retry if status != u'': break if status == "OK": return True elif
status == "ERR": return False else: try: return int(status) except ValueError: return status
def info(self): """ Description: Returns dict of information about the TV name, model, version """ return {"name": self._send_command('name'), "model": self._send_command('model'), "version": self._send_command('version'), "ip_version": self._send_command('ip_version') }
def get_input_list(self): """ Description: Get input list Returns an ordered list of all available input keys and names """ inputs = [' '] * len(self.command['input']) for key in self.command['input']: inputs[self.command['input'][key]['order']] = {"key":key, "name":self.command['input'][key]['name']} return inputs
def input(self, opt): """ Description: Set the input Call with no arguments to get current setting Arguments: opt: string Name provided from input list or key from yaml ("HDMI 1" or "hdmi_1") """ for key in self.command['input']: if (key == opt) or (self.command['input'][key]['name'] == opt): return self._send_command(['input', key, 'command']) return False
def digital_channel_air(self, opt1='?', opt2='?'): """ Description: Change Channel (Digital) Pass Channels "XX.YY" as TV.digital_channel_air(XX, YY) Arguments: opt1: integer 1-99: Major Channel opt2: integer (optional) 1-99: Minor Channel """ if opt1 == '?': parameter = '?' elif opt2 == '?': parameter = str(opt1).rjust(4, "0") else: parameter = '{:02d}{:02d}'.format(opt1, opt2) return self._send_command('digital_channel_air', parameter)
def digital_channel_cable(self, opt1='?', opt2=0): """ Description: Change Channel (Digital) Pass Channels "XXX.YYY" as TV.digital_channel_cable(XXX, YYY) Arguments: opt1: integer 1-999: Major Channel opt2: integer (optional) 0-999: Minor Channel """ if opt1 == '?': parameter = '?' elif self.command['digital_channel_cable_minor'] == '': parameter = str(opt1).rjust(4, "0") else: self._send_command('digital_channel_cable_minor', str(opt1).rjust(3, "0")) parameter = str(opt2).rjust(3, "0") return self._send_command('digital_channel_cable_major', parameter)
def get_remote_button_list(self): """ Description: Get remote button list Returns an list of all available remote buttons """ remote_buttons = [] for key in self.command['remote']: if self.command['remote'][key] != '': remote_buttons.append(key) return remote_buttons
def check_results(tmp_): """Return a 3 tuple for something.""" # TODO: Fix this to work with more meaningful names if tmp_['t'] > 0: if tmp_['l'] > 0: if tmp_['rr'] > 0 or tmp_['ra'] > 1: print 1, 3, tmp_ return 3 elif tmp_['cr'] > 0 or tmp_['ca'] > 1: print 2, 3, tmp_ return 3 elif tmp_['mr'] > 0 or tmp_['ma'] > 1: print 3,
2, tmp_ return 2 if tmp_['cr'] > 1 or tmp_['ca'] > 2: print 4, 2, tmp_ return 2 if tmp_['mr'] > 0 or tmp_['ma'] > 1: if tmp_['cr'] > 0 or tmp_['ca'] > 1: print 6, 0, tmp_ return 0 if tmp_['rr'] > 1 or tmp_['ra'] > 2: print 7, 0, tmp_ return 0 if tmp_['sr'] > 1 or tmp_['sa'] > 2: print 8,
0, tmp_ return 0 if tmp_['l'] > 0: if tmp_['rr'] > 0 or tmp_['ra'] > 1: print 9, 2, tmp_ return 2 if tmp_['cr'] > 0 or tmp_['ca'] > 1: print 10, 0, tmp_ return 0 return -1
def _check_animation(self, last, last_level, gen): """Internal helper function to check the animation.""" tmp_ = Counter() results = Counter() name, level, block = last, last_level, last others = False while name in self.ANIMATION and level >= last_level: if name in self.LOOP: if block != last: count = self.check_results(tmp_) if count > -1: results[count] += 1 tmp_.clear() tmp_['last'] += 1 for attribute in ('costume', 'orientation', 'position',
'size'): if (name, 'relative') in self.BLOCKMAPPING[attribute]: tmp_[(attribute, 'relative')] += 1 elif (name, 'absolute') in self.BLOCKMAPPING[attribute]: tmp_[(attribute, 'absolute')] += 1 if name in self.TIMING: tmp_['timing'] += 1 last_level = level name, level, block = next(gen, ('', 0, '')) # allow some exceptions if name not in self.ANIMATION and name != '': if not others: if block.type.shape != 'stack': last_level = level (name, level, block) =
next(gen, ('', 0, '')) others = True count = self.check_results(tmp_) if count > -1: results[count] += 1 return gen, results
def analyze(self, scratch, **kwargs): """Run and return the results from the Animation plugin.""" results = Counter() for script in self.iter_scripts(scratch): gen = self.iter_blocks(script.blocks) name = 'start' level = None while name != '': if name in self.ANIMATION: gen, count = self._check_animation(name, level, gen) results.update(count) name, level, _ = next(gen, ('', 0, '')) return {'animation': results}
def get_receive(self, script_list): """Return a list of received events contained in script_list.""" events = defaultdict(set) for script in script_list: if self.script_start_type(script) == self.HAT_WHEN_I_RECEIVE: event = script.blocks[0].args[0].lower() events[event].add(script) return events
def analyze(self, scratch, **kwargs): """Run and return the results from the BroadcastReceive plugin.""" all_scripts = list(self.iter_scripts(scratch)) results = defaultdict(set) broadcast = dict((x, self.get_broadcast_events(x)) # Events by script for x in all_scripts) correct = self.get_receive(all_scripts) results['never broadcast'] = set(correct.keys()) for script, events in broadcast.items(): for event in events.keys(): if event is True: # Remove dynamic broadcasts results['dynamic broadcast'].add(script.morph.name) del events[event] elif event in correct: results['never
broadcast'].discard(event) else: results['never received'].add(event) # remove events from correct dict that were never broadcast for event in correct.keys(): if event in results['never broadcast']: del correct[event] # Find scripts that have more than one broadcast event on any possible # execution path through the program # TODO: Permit mutually exclusive broadcasts for events in broadcast.values(): if len(events) > 1: for event in events: if event
in correct: results['parallel broadcasts'].add(event) del correct[event] # Find events that have two (or more) receivers in which one of the # receivers has a "delay" block for event, scripts in correct.items(): if len(scripts) > 1: for script in scripts: for _, _, block in self.iter_blocks(script.blocks): if block.type.shape == 'stack': results['multiple receivers with delay'].add(event) if event in correct: del correct[event] results['success'] = set(correct.keys()) return {'broadcast':
results}
def analyze(self, scratch, **kwargs): """Categorize instances of attempted say and sound synchronization.""" errors = Counter() for script in self.iter_scripts(scratch): prev_name, prev_depth, prev_block = '', 0, script.blocks[0] gen = self.iter_blocks(script.blocks) for name, depth, block in gen: if prev_depth == depth: if prev_name in self.SAY_THINK: if name == 'play sound %s until done': if not self.is_blank(prev_block.args[0]): errors += self.check(gen) # TODO: What about play sound? elif
prev_name in self.SAY_THINK_DURATION and \ 'play sound %s' in name: errors['1'] += 1 elif prev_name == 'play sound %s': if name in self.SAY_THINK: errors[self.INCORRECT] += 1 elif name in self.SAY_THINK_DURATION: if self.is_blank(block.args[0]): errors[self.ERROR] += 1 else: errors[self.HACKISH] += 1 elif prev_name == 'play sound %s until done' and \ name in self.ALL_SAY_THINK: if not self.is_blank(block.args[0]): errors[self.INCORRECT] += 1 # TODO: Should there be an
else clause here? prev_name, prev_depth, prev_block = name, depth, block return {'sound': errors}
def check(self, gen): """Check that the last part of the chain matches. TODO: Fix to handle the following situation that appears to not work say 'message 1' play sound until done say 'message 2' say 'message 3' play sound until done say '' """ retval = Counter() name, _, block = next(gen, ('', 0, '')) if name in self.SAY_THINK: if self.is_blank(block.args[0]): retval[self.CORRECT] += 1
else: name, _, block = next(gen, ('', 0, '')) if name == 'play sound %s until done': # Increment the correct count because we have at least # one successful instance retval[self.CORRECT] += 1 # This block represents the beginning of a second retval += self.check(gen) else: retval[self.INCORRECT] += 1 else: retval[self.INCORRECT] += 1 return retval
def _format_exception(err, is_failure, stdout=None, stderr=None): """Converts a sys.exc_info()-style tuple of values into a string.""" exctype, value, tb = err # Skip test runner traceback levels while tb and _is_relevant_tb_level(tb): tb = tb.tb_next if is_failure: # Skip assert*() traceback levels length = _count_relevant_tb_levels(tb) msgLines = traceback.format_exception(exctype, value, tb, length) else: msgLines = traceback.format_exception(exctype, value, tb) encoding = locale.getpreferredencoding() msgLines = [_decode(line, encoding) for line in